Initial public release

Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
Evan Whittaker
2026-10-17 12:08:30 -05:00
commit 09a7de2520
1730 changed files with 412952 additions and 0 deletions

View File

@@ -0,0 +1,44 @@
//! Live clipboard write, against the machine's real clipboard.
//!
//! This is the check that catches the class of bug where a copy lands somewhere the desktop's own
//! paste never looks — `arboard` built without `wayland-data-control` sets XWayland's X11 selection,
//! which `wl-paste` and a compositor keybinding never see, and which evaporates when the process
//! that owns it exits.
//!
//! **Opt-in**: it replaces whatever is on the clipboard, so a normal gate run must not do it. Run it
//! with `LUXE_CLIPBOARD_LIVE=1 cargo nextest run -p luxe-tui --features clipboard --test
//! clipboard_live`.
#![allow(clippy::unwrap_used)]
#[cfg(all(feature = "clipboard", target_os = "linux"))]
#[tokio::test]
async fn a_copy_is_readable_by_the_wayland_clipboard() {
use luxe_tui::clipboard::create_clipboard;
if std::env::var_os("LUXE_CLIPBOARD_LIVE").is_none() {
eprintln!("skipped: set LUXE_CLIPBOARD_LIVE=1 to let this replace the clipboard");
return;
}
if std::env::var_os("WAYLAND_DISPLAY").is_none() {
eprintln!("skipped: no WAYLAND_DISPLAY");
return;
}
if tokio::process::Command::new("wl-paste").arg("--version").output().await.is_err() {
eprintln!("skipped: wl-paste unavailable");
return;
}
let payload = format!("luxe clipboard check {}", std::process::id());
let sink = create_clipboard().await;
sink.write_text(&payload).await.expect("the write reaches a backend");
// wl-paste is the same path a compositor keybinding or another Wayland app would use.
let pasted = tokio::process::Command::new("wl-paste")
.arg("--no-newline")
.output()
.await
.expect("wl-paste runs");
let pasted = String::from_utf8_lossy(&pasted.stdout).to_string();
assert_eq!(pasted, payload, "the Wayland clipboard must hold what Luxe just copied");
}

View File

@@ -0,0 +1,305 @@
//! What one frame is allowed to allocate.
//!
//! Frame cost is the one property of a TUI that cannot be read off the source. A repaint that
//! looks linear may be memoized, and a memo that looks sound may have quietly stopped engaging —
//! and nothing fails until someone holds a key down on a long session and the screen stops moving.
//! That is exactly how the transcript came to re-parse, re-wrap and re-allocate its whole history
//! on every keystroke: three hundred thousand allocations a frame at four hundred turns, and no
//! test in the suite could tell.
//!
//! So the budget is **allocation count**, not wall time. It is identical on every machine and in
//! every CI runner, it does not flake, and it is the number that actually describes the mistake:
//! work proportional to the session rather than to the screen.
//!
//! A budget that fails is not automatically wrong. Read the number first — if a frame went from
//! 200 to 210 allocations because a surface gained a row, raise the ceiling and say so. If it went
//! to 200,000, something stopped being memoized.
//!
//! Allocation count cannot see everything, though, and the last test here is why. Guided Review
//! resolved a chapter's items by scanning every file's every hunk, once per chapter, on every
//! frame: quadratic in the size of the review, 23 ms a frame on a 784-file change — and it
//! allocated *nothing extra* doing it, so the counter above was flat across a sixteen-fold
//! increase in work. A scan is caught by the shape of the curve instead. Comparing one size
//! against another is safe where an absolute millisecond budget is not: the ratio divides the
//! machine out, so a slow runner moves both measurements together and cancels.
use luxe_core::config::Config;
use luxe_core::keymap::KeyMap;
use luxe_tui::app::{App, ConvoBlock, Msg};
use luxe_tui::fixture::{seeded_app, FixtureScenario};
use luxe_tui::view::render;
use ratatui::{backend::TestBackend, Terminal};
use std::alloc::{GlobalAlloc, Layout, System};
use std::cell::Cell;
// === Counting allocator ===
thread_local! {
/// Allocations on *this* thread, so tests sharing a process cannot pollute each other.
static ALLOCATIONS: Cell<usize> = const { Cell::new(0) };
}
/// Passes everything through to the system allocator and counts what went by.
struct Counting;
// SAFETY: every method forwards to `System` with its caller's own arguments, so it upholds exactly
// the contract `System` does; the counting beside it never allocates and cannot panic.
#[allow(unsafe_code)]
unsafe impl GlobalAlloc for Counting {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
// `try_with`, because a thread being torn down no longer has the slot — and a panic
// raised inside the allocator is not survivable.
let _ = ALLOCATIONS.try_with(|count| count.set(count.get() + 1));
unsafe { System.alloc(layout) }
}
unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
unsafe { System.dealloc(pointer, layout) }
}
unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
let _ = ALLOCATIONS.try_with(|count| count.set(count.get() + 1));
unsafe { System.realloc(pointer, layout, new_size) }
}
}
#[global_allocator]
static ALLOCATOR: Counting = Counting;
fn counted<T>(body: impl FnOnce() -> T) -> (T, usize) {
let before = ALLOCATIONS.with(Cell::get);
let value = body();
(value, ALLOCATIONS.with(Cell::get) - before)
}
// === Measurement ===
const WIDTH: u16 = 140;
const HEIGHT: u16 = 44;
/// Allocations in one steady-state frame — the cost of a keystroke that changed nothing.
///
/// The first frames are thrown away on purpose: they warm the syntax set, the highlight memo and
/// the transcript layout, and pricing a cold start as if it were a repaint is how a cache gets
/// declared useless.
fn steady_frame(app: &mut App, width: u16, height: u16) -> usize {
let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("a test terminal");
for _ in 0..3 {
terminal.draw(|frame| render(frame, app)).expect("a warm-up frame");
}
// Two frames, halved: a single one can catch a Vec growing into its final capacity.
let ((), allocations) = counted(|| {
for _ in 0..2 {
terminal.draw(|frame| render(frame, app)).expect("a frame");
}
});
allocations / 2
}
fn chat_app(turns: usize) -> App {
let (tx, _rx) = tokio::sync::mpsc::channel(64);
let mut app = App::new_fixture(tx, KeyMap::defaults(), Config::default());
app.headless = true;
app.update(Msg::TerminalResized { width: WIDTH, height: HEIGHT });
for index in 0..turns {
app.push_convo(ConvoBlock::User {
text: format!("question {index}"),
attached: Vec::new(),
chips: Vec::new(),
});
app.push_convo(ConvoBlock::Thinking {
text: format!(
"Reasoning {index}: consider the options, weigh them, then pick one, at about the \
length a reasoning block reaches before the answer starts."
),
expanded: true,
});
app.push_convo(ConvoBlock::Assistant(format!(
"Answer {index}: prose with `inline code`, **bold** and _emphasis_, long enough to \
wrap across several rows of the conversation canvas.\n\n- first\n- second\n\n```rust\n\
fn thing_{index}() -> usize {{ {index} }}\n```\n\nAnd a trailing paragraph."
)));
}
app
}
// === The budgets ===
/// The one that matters: a frame's cost must not grow with the length of the session.
///
/// Typing changes nothing about the transcript, so a keystroke on a four-hundred-turn session must
/// cost what a keystroke on a twenty-turn session costs. The margin is generous — the walk that
/// checks whether each item moved is genuinely proportional to the item count — but it is nowhere
/// near enough to hide a relayout, which runs to hundreds of allocations *per item*.
#[test]
fn a_frame_does_not_scale_with_the_length_of_the_session() {
let short = steady_frame(&mut chat_app(20), WIDTH, HEIGHT);
let long = steady_frame(&mut chat_app(400), WIDTH, HEIGHT);
assert!(
long <= short + 100,
"a 400-turn frame allocated {long} against a 20-turn frame's {short}; the transcript is \
being laid out again instead of reused"
);
}
/// And the absolute figure stays small, so "it did not get worse" cannot drift upward forever.
#[test]
fn a_steady_chat_frame_stays_within_its_budget() {
const BUDGET: usize = 400;
let allocations = steady_frame(&mut chat_app(150), WIDTH, HEIGHT);
assert!(
allocations <= BUDGET,
"a steady chat frame allocated {allocations}, over its budget of {BUDGET}"
);
}
/// Composing a long message must not cost per character.
///
/// The composer wraps the draft to answer three questions — how tall it is, what it draws, and
/// where the caret sits — and it once did that three times over, allocating a string per character
/// each time. A thousand-character draft is an ordinary message, and every keystroke redraws it.
#[test]
fn a_long_draft_does_not_cost_per_character() {
const BUDGET: usize = 800;
let mut app = chat_app(20);
for _ in 0..2000 {
app.editor.insert_text("x");
}
let allocations = steady_frame(&mut app, WIDTH, HEIGHT);
assert!(
allocations <= BUDGET,
"a frame with a 2000-character draft allocated {allocations}, over its budget of {BUDGET}"
);
}
/// Every other surface, held to a ceiling of its own.
///
/// These are bounded by what they show rather than by the session, so the numbers are small and
/// the point of the test is that they stay small — a sidebar that starts measuring its own wrapped
/// height per row is quadratic before anyone notices it slowed down.
#[test]
fn every_surface_stays_within_its_budget() {
let budgets = [
// The start screen draws the session's own composer and statusline under the wordmark now,
// which is two of the chat frame's three parts; it was 400 as a menu
(FixtureScenario::Dashboard, WIDTH, HEIGHT, 600usize),
(FixtureScenario::GuidedReviewReady, 170, 48, 1_000),
// Was 3,000, measured while the authorship guess folded every hunk here as "not written by
// the agent" (the fixture's provenance names none of its files). With that gone the frame
// draws the reading list it always should have; scaling is held by the linear test above.
(FixtureScenario::GuidedReviewLarge, 170, 48, 4_300),
(FixtureScenario::GuidedReviewGuideHidden, 170, 48, 800),
// Higher than the other diff surfaces because the preview now honors `diff.layout`
// like they do, so a wide one draws two columns where it used to draw one list.
(FixtureScenario::ChangesWide, 170, 48, 2_400),
(FixtureScenario::DockWide, 170, 48, 1_500),
(FixtureScenario::DockOverlay, 120, 40, 1_400),
(FixtureScenario::ChatTools, WIDTH, HEIGHT, 600),
(FixtureScenario::ChatCardBodies, WIDTH, HEIGHT, 600),
];
let mut over = Vec::new();
let mut measured = Vec::new();
for (scenario, width, height, budget) in budgets {
let mut app = seeded_app("luxe", scenario).expect("the fixture");
app.update(Msg::TerminalResized { width, height });
let allocations = steady_frame(&mut app, width, height);
measured.push(format!("{scenario:?}: {allocations}/{budget}"));
if allocations > budget {
over.push(format!("{scenario:?}: {allocations} allocations, budget {budget}"));
}
}
eprintln!("frame budgets: {}", measured.join(" \u{b7} "));
assert!(over.is_empty(), "surfaces over their frame budget: {}", over.join("; "));
}
/// Streaming redraws the tail. It must not redraw everything above it as well.
///
/// The reveal runs the loop at eighty frames a second while text arrives, so this is the frame
/// rate at which a transcript-wide relayout hurts most.
#[test]
fn streaming_a_reply_costs_the_tail_and_not_the_history() {
let mut app = chat_app(150);
app.push_convo(ConvoBlock::Assistant(String::new()));
let mut terminal = Terminal::new(TestBackend::new(WIDTH, HEIGHT)).expect("a test terminal");
for _ in 0..3 {
terminal.draw(|frame| render(frame, &mut app)).expect("a warm-up frame");
}
let mut worst = 0usize;
for chunk in ["Streaming ", "arrives in ", "pieces and ", "the tail ", "re-wraps."] {
if let Some(ConvoBlock::Assistant(tail)) =
app.convo.last_mut().map(luxe_tui::app::ConversationItem::block_mut)
{
tail.push_str(chunk);
}
let ((), allocations) = counted(|| {
terminal.draw(|frame| render(frame, &mut app)).map(|_| ()).expect("a frame")
});
worst = worst.max(allocations);
}
const BUDGET: usize = 600;
assert!(
worst <= BUDGET,
"the worst streaming frame allocated {worst}, over its budget of {BUDGET} — the history \
above the tail is being laid out again"
);
}
// === Scaling ===
/// The wall-clock cost of one Guided Review frame at `times` the large fixture.
///
/// The minimum of several runs, not the mean: noise only ever adds time, so the floor is the
/// stablest thing a loaded machine will report.
fn review_frame_ms(times: usize) -> f64 {
use luxe_core::guided_review::ReviewLoadRequestId;
use luxe_tui::app::ViewMode;
let review = luxe_tui::fixture::fixture_guided_review_scaled(times);
let mut app = seeded_app("luxe", FixtureScenario::GuidedReviewReady).expect("the fixture");
app.current_view = ViewMode::GuidedReview;
let request_id = ReviewLoadRequestId::new();
app.active_guided_review_request = Some(request_id.clone());
app.update(Msg::Engine(luxe_core::Event::GuidedReviewLoaded {
request_id,
review: Box::new(review),
}));
app.update(Msg::TerminalResized { width: 170, height: 48 });
let mut terminal = Terminal::new(TestBackend::new(170, 48)).expect("a test terminal");
for _ in 0..3 {
terminal.draw(|frame| render(frame, &mut app)).expect("a warm-up frame");
}
(0..7)
.map(|_| {
let started = std::time::Instant::now();
terminal.draw(|frame| render(frame, &mut app)).expect("a frame");
started.elapsed().as_secs_f64() * 1000.0
})
.fold(f64::INFINITY, f64::min)
}
/// A Guided Review frame must not cost more than linearly in the size of the review.
///
/// The walkthrough shows one file's diff and a bounded rail however large the change is, so the
/// only thing that may grow with the review is the bookkeeping — and that has to be lookups rather
/// than scans. Eight times the review measured 3.5x the frame when this was written and 35x before
/// the ids were indexed, so the ceiling sits an order of magnitude clear of the first and a third
/// of the way to the second.
///
/// A ratio rather than a millisecond budget on purpose: it divides the machine out, so a loaded CI
/// runner moves both measurements together instead of failing the test.
#[test]
fn a_guided_review_frame_does_not_scale_worse_than_linearly() {
let small = review_frame_ms(2);
let large = review_frame_ms(16);
let ratio = large / small;
assert!(
ratio < 12.0,
"eight times the review cost {ratio:.1}x the frame ({small:.3} ms -> {large:.3} ms); \
something in the review path is scanning where it should be looking up"
);
}

View File

@@ -0,0 +1,71 @@
//! Frame gutter — where Luxe draws relative to the edges it meets.
//!
//! The terminal's edge gets no air: Luxe draws flush to it and uses every column it was given,
//! which also lines it up with a host that frames the pane (herdr's tab row starts flush at the
//! pane's left edge). A rule Luxe drew itself keeps a column of air on the side facing the text.
//! These tests pin both halves.
use luxe_tui::app::{App, Msg};
use luxe_tui::fixture::{seeded_app, FixtureScenario};
use luxe_tui::view::render;
use ratatui::backend::TestBackend;
use ratatui::buffer::Buffer;
use ratatui::Terminal;
/// A wide chat so the dock sits beside the conversation and both edges are in play.
const WIDE: (u16, u16) = (160, 40);
fn draw(app: &mut App, (width, height): (u16, u16)) -> Buffer {
app.update(Msg::TerminalResized { width, height });
let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("terminal");
terminal.draw(|frame| render(frame, app)).expect("render");
terminal.backend().buffer().clone()
}
fn chat() -> Buffer {
let mut app = seeded_app("luxe", FixtureScenario::ChatTools).expect("fixture");
draw(&mut app, WIDE)
}
fn row_text(buffer: &Buffer, y: u16) -> String {
(0..buffer.area.width).map(|x| buffer[(x, y)].symbol()).collect()
}
fn inked(buffer: &Buffer, x: u16) -> bool {
(0..buffer.area.height).any(|y| buffer[(x, y)].symbol().trim() != "")
}
/// The row the dock's own PROJECT heading landed on.
fn project_slab_row(buffer: &Buffer) -> u16 {
(0..buffer.area.height)
.find(|&y| row_text(buffer, y).contains("PROJECT"))
.expect("the dock drew its PROJECT heading")
}
/// Both outer columns carry ink: a column of air there is a column of conversation the reader
/// does not get, and inside herdr it put the dock one cell right of the tab row above it.
#[test]
fn luxe_draws_flush_to_both_terminal_edges() {
let buffer = chat();
assert!(inked(&buffer, 0), "the left edge is drawn on");
assert!(inked(&buffer, buffer.area.width - 1), "the right edge is drawn on");
}
/// The inner gutter answers a different question — it keeps text off a rule Luxe owns — so it
/// stays. Measured off the dock separator, the one edge both columns meet.
#[test]
fn the_column_beside_the_dock_keeps_its_air() {
let buffer = chat();
let slab_row = project_slab_row(&buffer);
let separator = (0..buffer.area.width)
.find(|&x| buffer[(x, slab_row)].symbol() == "\u{2502}")
.expect("the dock separator");
let first_ink_after = (separator + 1..buffer.area.width)
.find(|&x| inked(&buffer, x))
.expect("the conversation drew something");
assert_eq!(
first_ink_after,
separator + 2,
"the conversation column stands one cell off the rule"
);
}

View File

@@ -0,0 +1,316 @@
//! Glyph tiers — the promise that turning the icons down costs shine and nothing else.
//!
//! Two claims are checked against **rendered buffers**, not against the vocabulary table, because the
//! table is only half the story: an icon can be portable and still wreck the surface it sits in.
//!
//! 1. Below the nerd tier, nothing on screen needs a patched font. A private-use codepoint reaching a
//! buffer is a leak — a glyph someone inlined instead of naming — and there are no exemptions.
//! There used to be one, for the wordmark's corner triangles, on the grounds that they were
//! chosen by a separate *measured* mechanism rather than by the font. Both the wordmark and the
//! slab have since retreated to Block Elements, so the range nothing draws is now the range
//! nothing may draw.
//! 2. Where an icon is *substituted*, the layout is identical. Icons are budgeted one cell each, so a
//! two-cell substitute would shift everything after it on the row; comparing each row's non-icon
//! skeleton catches that exactly, and catches an icon silently growing to two glyphs as well.
//!
//! Two surfaces deliberately lay out differently below the nerd tier, and each gets the assertion that
//! actually applies to it:
//!
//! - **Tool cards and tool preview lines omit their icon** rather than approximate it — the bold name
//! and the card's color already say which tool ran and how it went. The rule is therefore stated
//! generally rather than per surface: a row's *words* must be identical, and any shift must be
//! uniform across the row and exactly the width an omitted icon frees. A two-cell glyph fails it,
//! because its shift is neither zero nor uniform.
//! - **The dashboard at `ascii`** swaps the block-drawn logotype for the letter-spaced line, and a
//! narrower mark takes the whole left column with it — the same cascade a small terminal already
//! triggers. Icon width is still pinned there by the exhaustive table test in `glyphs.rs`.
//!
//! `nerd_wide` is the one tier those two claims do **not** cover, because it exists to break the
//! second on purpose: it is the shipped vocabulary drawn by a font cut whose icons carry two cells of
//! ink, so it hands each of them a second cell rather than pretending they fit one. Its own claim is
//! narrower and gets its own walk
//! ([`every_icon_gets_its_second_cell_at_the_wide_tier`]): the words are the nerd tier's words, and
//! every icon on screen has two cells of clearance after it instead of one.
//!
//! The tier is process-wide, so the tests that move it cannot run beside each other — hence
//! [`serial`] — and living in its own integration binary keeps it away from the unit tests, which
//! all assume the shipped look.
use luxe_tui::app::App;
use luxe_tui::fixture::{seeded_app, FixtureScenario};
use luxe_tui::glyphs::{set_tier, GlyphTier, EVERY_ICON, EVERY_MARK};
use luxe_tui::view::render;
use ratatui::backend::TestBackend;
use ratatui::buffer::Buffer;
use ratatui::Terminal;
const TIERS: [GlyphTier; 3] = [GlyphTier::Nerd, GlyphTier::Unicode, GlyphTier::Ascii];
/// The surfaces that carry icons, named the way the gate names them.
const SCENARIOS: [(&str, FixtureScenario); 6] = [
("dashboard", FixtureScenario::Dashboard),
("tool cards", FixtureScenario::ChatTools),
// A folded run puts an icon behind a spinner and in front of a meter, which is two more chances
// to spend a cell the plainer tiers do not.
("folded run", FixtureScenario::ChatToolRun),
// The rail in full, with a slab badge on every section heading.
("dock", FixtureScenario::DockWide),
// The bar in full: the dock's own scenario hides it, because at this width the sidebar sits
// beside the conversation and `auto` visibility stands down. This one carries every identity
// module *and* its slab caps, which are the one decoration budgeted a cell at every tier.
("statusline", FixtureScenario::ChatIdle),
("session picker", FixtureScenario::SessionPicker),
];
/// Take the process-wide glyph tier, at the shipped default.
///
/// `cargo test` runs one binary's tests on threads — nextest gives each its own process, which is
/// why the gate never saw this — so without a lock the tier one test sets lands in another's
/// render, and the failure surfaces on whichever one was unlucky. Acquiring resets to `Nerd` as
/// well, so a test that panics part-way through a walk cannot hand the next one a tier it never
/// asked for.
fn serial() -> std::sync::MutexGuard<'static, ()> {
static TIER: std::sync::Mutex<()> = std::sync::Mutex::new(());
let guard = TIER.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
set_tier(GlyphTier::Nerd);
guard
}
fn draw(app: &mut App, width: u16, height: u16) -> Buffer {
let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("terminal");
terminal.draw(|frame| render(frame, app)).expect("render");
terminal.backend().buffer().clone()
}
fn scenario_app(scenario: FixtureScenario) -> App {
seeded_app("tokyo-night", scenario).unwrap_or_else(|error| panic!("fixture: {error}"))
}
/// A row reduced to its words and their columns: every non-alphanumeric cell becomes a placeholder.
///
/// Blind to *which* shape drew a cell — the point is not to compare glyphs but to prove nothing moved.
/// An icon that measured two cells would push the text after it one column right, and the words would
/// stop lining up.
fn skeleton(buffer: &Buffer, y: u16) -> String {
(0..buffer.area.width)
.map(|x| match buffer[(x, y)].symbol().chars().next() {
Some(glyph) if glyph.is_alphanumeric() => glyph,
// ASCII on purpose: `str::find` returns byte offsets, and a multi-byte placeholder would
// make a two-column shift read as four.
_ => '.',
})
.collect()
}
/// An omitted icon frees its own cell and the space after it.
const OMITTED_ICON_COLUMNS: usize = 2;
/// The words on `buffer`'s rows, in order, ignoring where they landed.
fn every_word(buffer: &Buffer) -> Vec<Vec<String>> {
(0..buffer.area.height)
.map(|y| words(&skeleton(buffer, y)).into_iter().map(|(_, word)| word).collect())
.collect()
}
/// Every single-letter glyph the `ascii` tier can draw.
///
/// The tier's whole job is to stay inside ASCII, so a handful of its glyphs are letters — `v` for a
/// tick, `x` for a cross. To a tokenizer splitting on alphanumerics those are words, and a row that
/// swapped `✓` for `v` would read as having *gained* one. Derived from the vocabulary rather than
/// listed, so a new letter-shaped fallback cannot quietly start failing the comparison.
fn ascii_letter_glyphs() -> std::collections::HashSet<String> {
EVERY_ICON
.iter()
.map(|icon| icon.at(GlyphTier::Ascii))
.chain(EVERY_MARK.iter().map(|mark| mark.at(GlyphTier::Ascii)))
.filter(|glyph| glyph.chars().count() == 1)
.filter(|glyph| glyph.chars().all(char::is_alphanumeric))
.map(str::to_string)
.collect()
}
/// The words on a row, each with the column it starts at.
///
/// A letter-shaped `ascii` glyph is dropped from **both** sides of every comparison, so the filter
/// can hide a difference but never invent one.
fn words(row: &str) -> Vec<(usize, String)> {
let letters = ascii_letter_glyphs();
let mut found: Vec<(usize, String)> = Vec::new();
let mut current: Option<(usize, String)> = None;
for (column, glyph) in row.chars().enumerate() {
if glyph.is_alphanumeric() {
current.get_or_insert((column, String::new())).1.push(glyph);
} else if let Some(word) = current.take() {
found.push(word);
}
}
found.extend(current);
found.retain(|(_, word)| !letters.contains(word));
found
}
fn private_use(symbol: &str) -> Option<u32> {
symbol
.chars()
.map(u32::from)
.find(|cp| (0xE000..=0xF8FF).contains(cp) || (0xF0000..=0xFFFFD).contains(cp))
}
#[test]
fn every_tier_draws_the_same_layout_and_only_nerd_needs_a_patched_font() {
let _serial = serial();
// Sized so every scenario gets its wide layout, which is the one carrying the most icons.
let (width, height) = (170, 48);
for (name, scenario) in SCENARIOS {
let mut reference: Option<Vec<String>> = None;
for tier in TIERS {
set_tier(tier);
let buffer = draw(&mut scenario_app(scenario), width, height);
if tier != GlyphTier::Nerd {
for y in 0..buffer.area.height {
for x in 0..buffer.area.width {
let symbol = buffer[(x, y)].symbol();
if let Some(cp) = private_use(symbol) {
panic!(
"{name} at {tier:?} draws U+{cp:04X} at ({x}, {y}) — a private-use \
glyph reached the screen, so something inlined it instead of naming it \
in `glyphs.rs`"
);
}
}
}
}
let rows: Vec<String> = (0..buffer.area.height).map(|y| skeleton(&buffer, y)).collect();
match &reference {
None => reference = Some(rows),
Some(nerd) => {
if name == "dashboard" && tier == GlyphTier::Ascii {
continue; // deliberate: a different wordmark, and a different column with it
}
assert_eq!(rows.len(), nerd.len(), "{name} at {tier:?} changed its row count");
for (y, (row, expected)) in rows.iter().zip(nerd).enumerate() {
let (here, there) = (words(row), words(expected));
assert_eq!(
here.iter().map(|(_, word)| word).collect::<Vec<_>>(),
there.iter().map(|(_, word)| word).collect::<Vec<_>>(),
"{name} at {tier:?} row {y}: the words changed, not just the icons"
);
let shifts: Vec<usize> = here
.iter()
.zip(&there)
.map(|((here, _), (there, _))| there.saturating_sub(*here))
.collect();
for shift in &shifts {
assert!(
*shift == 0 || *shift == OMITTED_ICON_COLUMNS,
"{name} at {tier:?} row {y}: text moved {shift} columns, which is \
neither \"nothing changed\" nor \"an icon was omitted\""
);
}
assert!(
shifts.windows(2).all(|pair| pair[0] == pair[1]),
"{name} at {tier:?} row {y}: the row shifted unevenly ({shifts:?}), so \
something on it is not one cell wide"
);
}
}
}
}
}
set_tier(GlyphTier::Nerd);
}
/// The wide tier's whole job: the same surface, with a cell of air added between every icon and
/// whatever it labels.
///
/// Asserted over the *drawn* buffer rather than over the gap constant, because the constant is only
/// half of it — a surface that spaces its own icons with a literal keeps drawing them one cell apart
/// however the shared gap moves, and this is what catches that. The words are checked too: room is
/// supposed to come out of the slack a row already carries, and a row that pushed a word off its own
/// end instead has lost information rather than gained air.
#[test]
fn every_icon_gets_its_second_cell_at_the_wide_tier() {
let _serial = serial();
let (width, height) = (170, 48);
for (name, scenario) in SCENARIOS {
set_tier(GlyphTier::Nerd);
let narrow = draw(&mut scenario_app(scenario), width, height);
set_tier(GlyphTier::NerdWide);
let wide = draw(&mut scenario_app(scenario), width, height);
assert_eq!(
every_word(&wide),
every_word(&narrow),
"{name} at nerd_wide: the words changed, so the extra cell came out of the content"
);
for y in 0..wide.area.height {
for x in 0..wide.area.width {
if private_use(wide[(x, y)].symbol()).is_none() {
continue;
}
// The row's own right edge counts as clearance: an icon with nothing after it has
// nothing to crowd.
let clearance = (x + 1..wide.area.width)
.take(2)
.filter(|&next| wide[(next, y)].symbol() == " ")
.count();
assert!(
clearance == 2 || x + 2 >= wide.area.width,
"{name} at nerd_wide: the icon at ({x}, {y}) has {clearance} cells of \
clearance, so something spaced it with a literal instead of `icon_gap`"
);
}
}
}
set_tier(GlyphTier::Nerd);
}
/// The Powerline Extra range, at **every** tier including `nerd`.
///
/// The slab's caps were `U+E0BA`/`U+E0BC` until alacritty was measured drawing the second at 62%
/// fill, and the wordmark's chamfers were the other four before that. Nothing draws them now, and
/// the cheapest way to keep it that way is to say so: this is the assertion that turns "we stopped
/// using them" into "they cannot come back without deleting this test".
#[test]
fn no_surface_reaches_for_a_powerline_triangle_at_any_tier() {
let _serial = serial();
const TRIANGLES: std::ops::RangeInclusive<u32> = 0xE0B8..=0xE0BE;
for scenario in [FixtureScenario::ChatIdle, FixtureScenario::DockWide] {
for tier in TIERS {
set_tier(tier);
let buffer = draw(&mut scenario_app(scenario), 170, 48);
for y in 0..buffer.area.height {
for x in 0..buffer.area.width {
for glyph in buffer[(x, y)].symbol().chars() {
assert!(
!TRIANGLES.contains(&u32::from(glyph)),
"a Powerline triangle reached ({x}, {y}) at {tier:?} in {scenario:?}"
);
}
}
}
}
}
set_tier(GlyphTier::Nerd);
}
/// The default has to be the look Luxe ships with, so a surface rendered without any resolution step
/// is unchanged from before the tiers existed.
#[test]
fn the_untouched_default_is_the_nerd_vocabulary() {
let _serial = serial();
let mut app = scenario_app(FixtureScenario::ChatTools);
let buffer = draw(&mut app, 120, 40);
let found = (0..buffer.area.height)
.flat_map(|y| (0..buffer.area.width).map(move |x| (x, y)))
.any(|(x, y)| private_use(buffer[(x, y)].symbol()).is_some());
assert!(found, "the shipped look draws Material icons; none reached the buffer");
}

View File

@@ -0,0 +1,76 @@
//! Key labels — every key the TUI names is written in lower case.
//!
//! `ctrl+p` and `enter`, the way a keybindings file spells them, so a capital only ever means
//! Shift: `G` is Shift+G, and `ctrl+p` can't be misread as Ctrl+Shift+P the way `Ctrl+P` could.
//! A label from the keymap gets this from `KeyChord`'s `Display`; the ones written by hand in hint
//! rows and fallbacks are what this holds to it, since nothing else would notice one slip back.
use std::path::{Path, PathBuf};
/// Hand-written spellings that break the rule, as they would sit in a string literal.
const CAPITALIZED: &[&str] = &[
"Ctrl+",
"Alt+",
"Shift+",
"Option+",
"\"Enter ",
"\"Esc ",
"\"Tab ",
"\"Space ",
"· Enter ",
"· Esc ",
"· Tab ",
"· Space ",
"\" Enter ",
"\" Esc ",
"\"Enter\"",
"\"Esc\"",
"\"Tab\"",
"\"Space\"",
"PgUp",
"PgDn",
];
fn sources(dir: &Path, found: &mut Vec<PathBuf>) {
for entry in std::fs::read_dir(dir).expect("a source folder").flatten() {
let path = entry.path();
if path.is_dir() {
sources(&path, found);
} else if path.extension().is_some_and(|extension| extension == "rs") {
found.push(path);
}
}
}
/// The lines of `text` that ship: no comments, nothing from a test module onward, and none of a
/// file that is only tests.
fn shipped(text: &str) -> impl Iterator<Item = (usize, &str)> {
let only_tests = text.lines().take(40).any(|line| line.starts_with("use super::*"))
&& !text.contains("#[cfg(test)]");
text.lines()
.enumerate()
.take_while(move |(_, line)| !only_tests && !line.trim_start().starts_with("#[cfg(test)]"))
.filter(|(_, line)| !line.trim_start().starts_with("//"))
}
#[test]
fn every_key_the_tui_names_is_lower_case() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let mut files = Vec::new();
sources(&root.join("src"), &mut files);
sources(&root.join("../luxe-core/src/keymap"), &mut files);
let mut capitalized = Vec::new();
for file in files {
let name = file.file_name().and_then(|name| name.to_str()).unwrap_or_default();
if name == "tests.rs" || name.ends_with("_keys.rs") {
continue;
}
let text = std::fs::read_to_string(&file).expect("readable source");
for (index, line) in shipped(&text) {
if let Some(spelling) = CAPITALIZED.iter().find(|spelling| line.contains(*spelling)) {
capitalized.push(format!("{}:{}: {spelling}", file.display(), index + 1));
}
}
}
assert!(capitalized.is_empty(), "write keys in lower case:\n{}", capitalized.join("\n"));
}

View File

@@ -0,0 +1,211 @@
//! Panel chrome — the invariants that keep every bordered surface reading as one product.
//!
//! Two rules are enforced here, because they are the ones that silently rot as surfaces are added:
//! a panel's title is an accent glyph plus a **bold** label, and the focused row of a list is
//! **bold** on the selection background. A third test guards the seam itself — every bordered
//! panel must be built by `widgets::panel_block`/`titled_panel`, never hand-rolled.
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use luxe_core::config::Config;
use luxe_core::keymap::KeyMap;
use luxe_tui::app::{App, Msg};
use luxe_tui::glyphs::Icon;
use luxe_tui::view::render;
use ratatui::backend::TestBackend;
use ratatui::buffer::Buffer;
use ratatui::style::Modifier;
use ratatui::Terminal;
fn app() -> App {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
App::new(tx, KeyMap::defaults(), Config::default())
}
fn draw(app: &mut App, width: u16, height: u16) -> Buffer {
let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("terminal");
terminal.draw(|frame| render(frame, app)).expect("render");
terminal.backend().buffer().clone()
}
fn key(code: KeyCode) -> KeyEvent {
KeyEvent::new(code, KeyModifiers::NONE)
}
fn row_text(buffer: &Buffer, y: u16) -> String {
(0..buffer.area.width).map(|x| buffer[(x, y)].symbol()).collect()
}
/// Asserts the panel identified by `glyph` wears the shared title chrome: the glyph in the theme
/// accent, one space, then `label` in bold.
fn assert_panel_title(buffer: &Buffer, app: &App, glyph: &str, label: &str) {
let row = (0..buffer.area.height)
.find(|&y| row_text(buffer, y).contains(glyph))
.unwrap_or_else(|| panic!("no rendered row carries the {label:?} title glyph"));
let text = row_text(buffer, row);
let glyph_x = text.find(glyph).map(|byte| text[..byte].chars().count() as u16).expect("glyph");
assert_eq!(
buffer[(glyph_x, row)].fg,
app.theme_styles.accent.fg.expect("the theme defines an accent"),
"{label}: the title glyph is drawn in the accent color"
);
// " {glyph} {label} " — the label starts two cells past the glyph.
for (offset, character) in label.chars().enumerate() {
let cell = &buffer[(glyph_x + 2 + offset as u16, row)];
assert_eq!(cell.symbol(), character.to_string(), "{label}: title text at +{offset}");
assert!(cell.modifier.contains(Modifier::BOLD), "{label}: the title label must be bold");
}
}
/// Asserts the row carrying the `❯` cursor is highlighted *and* bold, so the selection survives
/// a terminal that drops backgrounds. Every list row is `{cursor}{space}{label}`.
fn assert_focused_row(buffer: &Buffer, app: &App, surface: &str) {
let selected_bg = app.theme_styles.selected_bg.bg.expect("the theme defines a selection bg");
let row = (0..buffer.area.height)
.find(|&y| row_text(buffer, y).contains('❯'))
.unwrap_or_else(|| panic!("{surface}: no row carries the selection cursor"));
let text = row_text(buffer, row);
let cursor_x =
text.find('❯').map(|byte| text[..byte].chars().count() as u16).expect("cursor column");
let label = &buffer[(cursor_x + 2, row)];
assert_eq!(label.bg, selected_bg, "{surface}: focused row is highlighted");
assert!(
label.modifier.contains(Modifier::BOLD),
"{surface}: focused row label must be bold, not color-only"
);
}
#[test]
fn the_slash_flyout_wears_the_shared_chrome() {
let mut app = app();
app.update(Msg::Key(key(KeyCode::Char('/'))));
let buffer = draw(&mut app, 80, 24);
assert_panel_title(&buffer, &app, Icon::SlashMenu.glyph(), "Commands");
assert_focused_row(&buffer, &app, "slash flyout");
}
#[test]
fn the_mention_flyout_wears_the_shared_chrome() {
let mut app = app();
app.update(Msg::Key(key(KeyCode::Char('@'))));
let buffer = draw(&mut app, 80, 24);
assert_panel_title(&buffer, &app, Icon::FileMenu.glyph(), "Files");
assert_focused_row(&buffer, &app, "mention flyout");
}
#[test]
fn the_command_palette_wears_the_shared_chrome() {
let mut app = app();
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL)));
assert!(app.overlays.palette.is_some(), "ctrl+k opens the palette");
let buffer = draw(&mut app, 80, 24);
assert_panel_title(&buffer, &app, Icon::Palette.glyph(), "Command palette");
}
#[test]
fn the_transcript_search_bar_wears_the_shared_chrome() {
let mut app = app();
app.search_state.searching = true;
app.search_state.query = "notification".into();
let buffer = draw(&mut app, 80, 24);
assert_panel_title(&buffer, &app, Icon::Search.glyph(), "Search conversation");
// The field keeps the pickers' inline `Search:` label so the input is findable at a glance.
let field = (0..24)
.map(|y| row_text(&buffer, y))
.find(|text| text.contains("Search:"))
.expect("the search field keeps its inline label");
assert!(field.contains("Search: notification"), "query follows the label: {field:?}");
}
/// The palette highlights fuzzy matches in accent-bold; the rest of the focused row must still be
/// bold so an empty query (no matches to highlight) still shows where the cursor is.
#[test]
fn the_palettes_focused_row_is_bold_without_a_query() {
let mut app = app();
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL)));
let buffer = draw(&mut app, 80, 24);
assert_focused_row(&buffer, &app, "command palette");
}
/// Overlays render over `Clear`, which resets cells to the *terminal's* background. Without an
/// explicit repaint a light theme shows a dark hole in a dark terminal (and vice versa), so every
/// overlay body must come back carrying the theme canvas color.
#[test]
fn overlays_repaint_the_theme_background_over_clear() {
// A light palette, which is the case that shows the hole, and a dark built-in
for light in [true, false] {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(
tx,
KeyMap::defaults(),
Config { theme: Some("nord".into()), ..Default::default() },
);
if light {
app.theme_styles = luxe_tui::fixture::light_theme_styles();
}
app.update(Msg::Key(key(KeyCode::Char('/'))));
let buffer = draw(&mut app, 80, 24);
let canvas = app.theme_styles.background.bg.expect("the theme defines a canvas");
let top = (0..24)
.find(|&y| (0..80).any(|x| buffer[(x, y)].symbol() == "╭"))
.expect("flyout top border");
let left = (0..80).find(|&x| buffer[(x, top)].symbol() == "╭").expect("flyout left edge");
// A cell inside the frame that no row text or selection highlight reaches.
let body = &buffer[(left + 40, top + 3)];
assert_eq!(
body.bg, canvas,
"light {light}: overlay body must not fall through to the terminal"
);
}
}
/// Guard the seam: a new surface must not hand-roll its frame or its title. Both would drift out of
/// the shared language the moment the border style or the title convention changes.
#[test]
fn bordered_panels_are_built_by_the_shared_constructors() {
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
let owner = root.join("widgets").join("panel.rs");
let mut offenders = Vec::new();
let mut stack = vec![root.clone()];
while let Some(dir) = stack.pop() {
for entry in std::fs::read_dir(&dir).expect("readable source dir") {
let path = entry.expect("readable entry").path();
if path.is_dir() {
stack.push(path);
continue;
}
if path.extension().is_none_or(|ext| ext != "rs") || path == owner {
continue;
}
let source = std::fs::read_to_string(&path).expect("readable source file");
let relative = path.strip_prefix(&root).unwrap_or(&path).display().to_string();
for (number, line) in source.lines().enumerate() {
let line = line.trim();
if line.starts_with("//") {
continue;
}
if line.contains("Borders::ALL") {
offenders
.push(format!("{relative}:{}: use widgets::panel_block()", number + 1));
}
if line.contains(".title(\"") {
offenders.push(format!(
"{relative}:{}: use widgets::titled_panel()/panel_title()",
number + 1
));
}
}
}
}
assert!(offenders.is_empty(), "hand-rolled panel chrome:\n {}", offenders.join("\n "));
}

View File

@@ -0,0 +1,236 @@
//! Activity — live activity beside the conversation, the statusline, the clipboard and search.
use super::*;
/// The live activity indicator belongs to the conversation, not the sidebar: even beside a
/// full-height dock it renders once, in the conversation column directly above the composer.
#[test]
fn live_activity_sits_below_the_conversation_even_beside_the_dock() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("activity"));
app.status.state = luxe_tui::app::AppState::Streaming;
app.status.spinner_frame = 0;
app.status.active_tool = Some("bash".into());
app.status.on_turn_start();
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("PROJECT"), "the wide layout puts the dock beside the conversation");
let rows = (0..height)
.filter(|&row| row_text(&buffer, row, width).contains(ACTIVITY_BAR_TRACK))
.collect::<Vec<_>>();
assert_eq!(rows.len(), 1, "exactly one activity indicator on screen, got rows {rows:?}");
// In the conversation column (right of the left rail), above the prompt box.
let row = rows[0];
let column =
row_text(&buffer, row, width).find(ACTIVITY_BAR_TRACK).expect("the indicator") as u16;
assert!(
column > luxe_tui::workspace_layout::LEFT_RAIL_WIDTH,
"the indicator is in the conversation column, not the sidebar: column {column}"
);
assert!(row < height - 1, "and above the prompt: row {row}");
}
#[test]
fn composer_activity_shows_above_the_prompt_when_the_dock_is_hidden() {
let (width, height) = (120, 32);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("above-composer"));
// Standard width keeps the dock hidden (auto), so activity rides above the composer instead.
app.status.state = luxe_tui::app::AppState::Streaming;
app.status.spinner_frame = 0;
app.status.active_tool = Some("bash".into());
app.status.on_turn_start();
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(!content.contains("PROJECT"), "dock should be hidden at standard width: {content}");
let activity_row = (0..height)
.find(|&row| row_text(&buffer, row, width).contains(ACTIVITY_BAR_TRACK))
.expect("activity row above the composer");
// It sits above the composer/statusline, not on the bottom row.
assert!(activity_row < height - 1, "activity should sit above the prompt: row {activity_row}");
}
/// The indicator above the composer is a sweeping bar of units, not a glyph plus the word
/// "working": the motion says "running", and only the two informative bits (elapsed, interrupt
/// chord) follow it. The units are packed — the shaded comet is what gives the sweep its shape, and
/// a separator between cells breaks the flow it draws.
#[test]
fn the_activity_indicator_is_a_sweeping_bar_with_elapsed_and_the_interrupt_chord() {
let (width, height) = (120, 32);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.status.state = luxe_tui::app::AppState::Streaming;
app.status.on_turn_start();
let first = render_app(&mut app, &backend);
let row = (0..height)
.find(|&row| row_text(&first, row, width).contains(ACTIVITY_BAR_TRACK))
.expect("the activity bar renders while a turn runs");
let text = row_text(&first, row, width);
assert!(!text.contains("working"), "the bar replaces the label: {text:?}");
assert!(text.contains("to interrupt"), "the interrupt chord stays: {text:?}");
assert!(text.contains("0.0s") || text.contains("s"), "elapsed stays: {text:?}");
let track = ACTIVITY_BAR_TRACK.chars().next().expect("one glyph");
let bar_of =
|row: &str| row.chars().filter(|g| ACTIVITY_BAR_GLYPHS.contains(g)).collect::<String>();
assert_eq!(bar_of(&text).chars().count(), 24, "one glyph per cell, packed: {text:?}");
assert!(!text.contains(&format!("{track} {track}")), "and no separator between them: {text:?}");
// The comet travels with the animation frame: two ticks per cell, so six ticks is three cells.
// Compare the whole bar rather than its leading cell — late in a leg the head is already off the
// rail while the tail drains, so the first lit cell can hold still while the comet moves.
for _ in 0..6 {
app.update(Msg::Tick);
}
let moved = row_text(&render_app(&mut app, &backend), row, width);
assert_ne!(bar_of(&text), bar_of(&moved), "the comet must sweep: {text:?} then {moved:?}");
// Idle rows stay empty: the strip is the composer's breathing space when nothing is running.
app.status.state = luxe_tui::app::AppState::Idle;
let idle = row_text(&render_app(&mut app, &backend), row, width);
assert!(!idle.contains(ACTIVITY_BAR_TRACK), "no bar when idle: {idle:?}");
}
#[test]
fn standard_layout_shows_the_statusline_when_the_dock_is_hidden() {
let (width, height) = (120, 32);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("fallback"));
app.push_convo(ConvoBlock::Assistant("chat stays primary".into()));
let content = buffer_to_string(&render_app(&mut app, &backend));
// Auto dock is hidden below the wide threshold, so the compact statusline takes over.
assert!(!content.contains("PROJECT"), "dock should be hidden on standard width: {content}");
assert!(content.contains("chat stays primary"), "conversation should stay primary: {content}");
// With the dock hidden, the project identity only appears on the compact statusline fallback.
assert!(
content.contains("luxe"),
"statusline should be the compact fallback carrying the project: {content}"
);
}
#[test]
fn hidden_statusline_bottom_aligns_the_composer() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("bottom-align"));
let buffer = render_app(&mut app, &backend);
// Wide default hides the statusline, so the composer outline touches the final row inside the
// main column (x = left-rail dock + 1-cell separator + 1-cell gutter).
let composer_x = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH
+ luxe_tui::workspace_layout::CONTEXT_DOCK_SEPARATOR_WIDTH
+ 1;
assert_eq!(
buffer[(composer_x, height - 1)].symbol(),
"╰",
"composer should bottom-align when the statusline is hidden: {}",
buffer_to_string(&buffer)
);
}
/// Helper to convert a ratatui Buffer to a string for assertions.
#[allow(deprecated)]
pub(super) fn buffer_to_string(buffer: &Buffer) -> String {
let mut content = String::new();
for row in 0..buffer.area.height {
for col in 0..buffer.area.width {
let cell = buffer.get(col, row);
content.push_str(cell.symbol());
}
content.push('\n');
}
content
}
/// Clipboard: MockClipboard writes without error.
#[tokio::test]
async fn test_mock_clipboard_write() {
let cb = luxe_tui::clipboard::MockClipboard;
let result = cb.write_text("hello").await;
assert!(result.is_ok());
}
/// Search: entering search mode allows typing 'n' (which is the navigation key).
#[test]
fn test_search_allows_typing_n() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
// Enter search mode by setting the flag directly.
app.search_state.searching = true;
assert!(app.search_state.is_active());
assert!(app.search_state.query.is_empty());
// Simulate typing 'n'.
let key = KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE);
let action = route_key(&mut app, &key);
// Should NOT be a navigation action (query is empty).
assert!(!matches!(action, RouteAction::SearchNavigate(_)));
// Query should now contain 'n'.
assert_eq!(app.search_state.query, "n");
}
/// Search: Enter navigates to next match; 'n' types into query.
#[test]
fn test_search_enter_navigates() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
// Enter search mode and set a query.
app.search_state.searching = true;
app.search_state.query = "hello".to_string();
assert_eq!(app.search_state.query, "hello");
// Enter should navigate.
let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE);
let action = route_key(&mut app, &key);
assert!(matches!(action, RouteAction::SearchNavigate(true)));
}
/// Search: typing 'n' into query does NOT navigate (fixes reviewer finding #2).
#[test]
fn test_search_n_types_into_query() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
// Enter search mode and start typing "mai".
app.search_state.searching = true;
for c in "mai".chars() {
let key = KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE);
let _ = route_key(&mut app, &key);
}
assert_eq!(app.search_state.query, "mai");
// Now 'n' should TYPE, not navigate.
let key = KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE);
let action = route_key(&mut app, &key);
assert!(!matches!(action, RouteAction::SearchNavigate(_)));
assert_eq!(app.search_state.query, "main");
}
/// Search: Up = prev match, Down = next match (spec: "Down/Up jump to next/prev").
#[test]
fn test_search_up_down_navigate() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.search_state.searching = true;
app.search_state.query = "hello".to_string();
// Up should navigate backward (prev).
let key = KeyEvent::new(KeyCode::Up, KeyModifiers::NONE);
let action = route_key(&mut app, &key);
assert!(matches!(action, RouteAction::SearchNavigate(false)));
// Down should navigate forward (next).
let key = KeyEvent::new(KeyCode::Down, KeyModifiers::NONE);
let action = route_key(&mut app, &key);
assert!(matches!(action, RouteAction::SearchNavigate(true)));
}

View File

@@ -0,0 +1,222 @@
//! Canvas — theme colors, prose width and alignment, and the borderless conversation.
use super::*;
/// Test that theme styles actually influence rendered colors (P18 gate).
#[test]
fn test_theme_styles_affect_rendered_colors() {
let tool = card_with_arguments("bash", "ls", serde_json::json!({"command": "ls"}));
let convo = vec![
ConvoBlock::User { text: "user".to_string(), attached: Vec::new(), chips: Vec::new() },
ConvoBlock::Assistant("assistant".to_string()),
ConvoBlock::Tool(Box::new(tool)),
ConvoBlock::System("system".to_string()),
];
let backend_a = test_backend(80, 24);
let mut app_a = create_app_with_theme("dark");
for block in &convo {
app_a.push_convo(block.clone());
}
let buffer_a = render_app(&mut app_a, &backend_a);
let backend_b = test_backend(80, 24);
let mut app_b = create_app_with_light_theme();
for block in convo {
app_b.push_convo(block);
}
let buffer_b = render_app(&mut app_b, &backend_b);
let buffers_differ = buffer_a
.content
.iter()
.zip(buffer_b.content.iter())
.any(|(a, b)| a.fg != b.fg || a.bg != b.bg);
assert!(buffers_differ, "Dark and light themes should produce different rendered colors");
assert_eq!(buffer_b[(0, 0)].bg, ratatui::style::Color::Rgb(0xef, 0xf1, 0xf5));
}
#[test]
fn light_theme_assistant_markdown_uses_the_configured_text_foreground() {
let (width, height) = (80, 16);
let backend = test_backend(width, height);
let mut app = create_app_with_light_theme();
app.push_convo(ConvoBlock::Assistant("LIGHT_THEME_PROSE".into()));
let buffer = render_app(&mut app, &backend);
let (x, y) = marker_position(&buffer, "LIGHT_THEME_PROSE", width, height);
assert_eq!(buffer[(x, y)].fg, ratatui::style::Color::Rgb(0x4c, 0x4f, 0x69));
}
#[test]
fn configured_prose_width_centers_assistant_markdown_without_narrowing_code() {
let (width, height) = (200, 18);
let backend = test_backend(width, height);
let mut app = create_app();
app.config.conversation.prose_max_width = Some(72);
app.config.conversation.alignment = Some(ConversationAlignment::Center);
app.push_convo(ConvoBlock::Assistant(
"CONFIGURED_PROSE\n\n```rust\nCONFIGURED_CODE\n```".to_string(),
));
let buffer = render_app(&mut app, &backend);
assert_eq!(marker_position(&buffer, "CONFIGURED_PROSE", width, height).0, 62);
assert_eq!(marker_position(&buffer, "CONFIGURED_CODE", width, height).0, 28);
}
#[test]
fn markdown_prose_and_code_use_distinct_conversation_canvases_when_centered() {
// Centering splits the slack of the *padded* content region, so a capped block sits one cell
// left of the band's own center; an uncapped one still hugs the gutter.
for (width, prose_x, wide_x) in [(200, 38, 28), (140, 8, 1), (78, 1, 1)] {
let backend = test_backend(width, 18);
let mut app = create_app();
app.config.conversation.alignment = Some(ConversationAlignment::Center);
app.push_convo(ConvoBlock::Assistant(
"PROSE_CANVAS\n\n```rust\nWIDE_CANVAS\n```".to_string(),
));
let buffer = render_app(&mut app, &backend);
let prose = marker_position(&buffer, "PROSE_CANVAS", width, 18);
let wide = marker_position(&buffer, "WIDE_CANVAS", width, 18);
assert_eq!(prose.0, prose_x, "prose x at width {width}");
assert_eq!(wide.0, wide_x, "wide x at width {width}");
assert_eq!(buffer[(width - 1, prose.1)].symbol(), " ");
assert_eq!(buffer[(width - 1, wide.1)].symbol(), " ");
}
}
#[test]
fn default_full_alignment_fills_the_width_from_the_left_gutter() {
// The default policy fills the pane: prose and code share the left gutter and neither is
// capped, so a wide terminal isn't left mostly empty.
let width = 200;
let backend = test_backend(width, 18);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("PROSE_CANVAS\n\n```rust\nWIDE_CANVAS\n```".to_string()));
let buffer = render_app(&mut app, &backend);
let prose = marker_position(&buffer, "PROSE_CANVAS", width, 18);
let wide = marker_position(&buffer, "WIDE_CANVAS", width, 18);
assert_eq!(prose.0, wide.0, "prose and code share the left edge");
assert!(prose.0 <= 2, "content hugs the left gutter, got x={}", prose.0);
// And `left` remains available for anyone who wants the readable caps back.
let mut capped = create_app_with_config(Config {
conversation: luxe_core::config::ConversationConfig {
alignment: Some(ConversationAlignment::Left),
..Default::default()
},
..Default::default()
});
capped.push_convo(ConvoBlock::Assistant("PROSE_CANVAS".to_string()));
let buffer = render_app(&mut capped, &backend);
assert!(marker_position(&buffer, "PROSE_CANVAS", width, 18).0 <= 2);
}
/// Text used to run flush into the right edge of a band: the canvas wrapped to the band's full
/// width, so a hard-wrapped row's last character landed on the band's last cell.
#[test]
fn banded_blocks_keep_a_cell_of_padding_at_both_edges() {
let (width, height) = (60u16, 24u16);
let backend = test_backend(width, height);
let mut app = create_app();
// Unbroken tokens, so every row but the last is filled to the wrap limit exactly — word wrap
// would leave a ragged edge and prove nothing.
app.push_convo(ConvoBlock::User {
text: "u".repeat(180),
attached: Vec::new(),
chips: Vec::new(),
});
let mut activity = ToolActivity::running("session-a", "call-a", "bash", "b".repeat(140), 1);
activity.state = ToolActivityState::Succeeded;
activity.elapsed_ms = Some(1_240);
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let buffer = render_app(&mut app, &backend);
let bands = [
app.theme_styles.user_msg_bg.bg.expect("a user band color"),
app.theme_styles.tool_call_success_bg.bg.expect("a tool band color"),
];
let mut filled_rows = 0;
for y in 0..height {
let Some(right_edge) = (0..width).rev().find(|&x| bands.contains(&buffer[(x, y)].bg))
else {
continue;
};
let Some(left_edge) = (0..width).find(|&x| bands.contains(&buffer[(x, y)].bg)) else {
continue;
};
let Some(last_text) =
(left_edge..=right_edge).rev().find(|&x| buffer[(x, y)].symbol() != " ")
else {
continue; // the band's own blank pad row, above and below the text
};
assert!(
last_text < right_edge,
"row {y} runs flush into the band's right edge at x={right_edge}"
);
assert!(
buffer[(left_edge, y)].symbol() == " ",
"row {y} runs flush into the band's left edge at x={left_edge}"
);
if last_text + 1 == right_edge {
filled_rows += 1;
}
}
assert!(filled_rows >= 2, "the fixture must actually fill rows to the wrap limit");
}
pub(super) fn marker_position(
buffer: &Buffer,
marker: &str,
width: u16,
height: u16,
) -> (u16, u16) {
for y in 0..height {
if let Some(x) = row_text(buffer, y, width).find(marker) {
return (x as u16, y);
}
}
panic!("missing marker {marker:?}");
}
/// Helper: dump a buffer row into a String of cell.symbol()s.
pub(super) fn row_text(buffer: &Buffer, y: u16, width: u16) -> String {
(0..width).map(|x| buffer[(x, y)].symbol()).collect()
}
/// A long conversation stays virtualized without reintroducing a frame.
#[test]
fn test_conversation_is_borderless_and_separate_from_composer() {
let (w, h) = (40u16, 8u16);
let backend = test_backend(w, h);
let mut app = create_app();
app.status.model = "gpt-4o".into();
for i in 0..30 {
app.push_convo(ConvoBlock::Assistant(format!("line number {i}")));
}
let buffer = render_app(&mut app, &backend);
// Virtualized window follows the bottom, so the newest line is visible (exact top row depends
// on inter-message spacing).
let full = (0..h).map(|y| row_text(&buffer, y, w)).collect::<Vec<_>>().join("\n");
assert!(full.contains("line number 29"), "latest conversation window missing: {full:?}");
let top = row_text(&buffer, 0, w);
assert_eq!(buffer[(0, 0)].symbol(), " ", "conversation should have no left border");
assert!(!top.contains("Conversation"));
assert!(row_text(&buffer, h - 4, w).trim_start().starts_with('╭'), "composer outline missing");
assert!(row_text(&buffer, h - 5, w).trim().is_empty(), "conversation gap missing");
assert!(
row_text(&buffer, h - 2, w).trim_start().starts_with('╰'),
"composer should touch statusline"
);
// The flat bar carries the model on its bottom row (mode label is gone).
assert!(row_text(&buffer, h - 1, w).contains("gpt-4o"));
}

View File

@@ -0,0 +1,534 @@
//! Cards — tool cards, their diffs and what a rejected edit says.
use super::*;
/// Tool cards read as a sentence, not a payload, and edit results render as a line-numbered diff
/// with elision instead of `@@` hunk headers.
#[test]
fn tool_cards_show_human_labels_and_line_numbered_diffs() {
let (width, height) = (100, 24);
let backend = test_backend(width, height);
let mut app = create_app();
// A tool with no path/command/query key used to fall back to its raw argument JSON.
let arguments = serde_json::json!({"action": "add", "subject": "wire the dock"});
let label = luxe_core::describe_call("todo", &arguments, "/project");
let mut todo = ToolActivity::running("session-a", "call-todo", "todo", label, 1);
todo.state = ToolActivityState::Succeeded;
todo.summary = Some("Completed".into());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: todo,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let mut edit = ToolActivity::running("session-a", "call-edit", "edit", "src/lib.rs", 1);
edit.state = ToolActivityState::Succeeded;
edit.summary = Some("Completed".into());
edit.output_preview = Some(
"Applied 1 edit(s) to 'src/lib.rs'\n ...\n 11 fn main() {\n-12 old();\n+12 new();\n 13 }\n ..."
.into(),
);
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: edit,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("add · wire the dock"), "human tool label: {content}");
assert!(!content.contains("\"action\""), "no raw argument JSON: {content}");
assert!(!content.contains("@@"), "no unified hunk headers on the card: {content}");
assert!(content.contains("-12"), "removed line carries its number: {content}");
assert!(content.contains("+12"), "added line carries its number: {content}");
assert!(content.contains('⋯'), "elided context is marked: {content}");
assert!(!content.contains("Completed"), "a green card already says it completed: {content}");
assert!(
!content.contains("Applied 1 edit"),
"the header already names the file it edited: {content}"
);
}
/// Builds a succeeded card for `tool`, with a body taken from the call's arguments the way the live
/// projection does.
pub(super) fn card_with_arguments(
tool: &str,
label: &str,
arguments: serde_json::Value,
) -> ToolItem {
let mut activity = ToolActivity::running("session-a", "call-a", tool, label, 1);
activity.state = ToolActivityState::Succeeded;
activity.summary = Some("Completed".into());
activity.card_body = luxe_core::tool_card_body(tool, &arguments, "/project");
ToolItem { activity, expanded: false, details_toggled: false, waited_on_user_ms: 0 }
}
/// A `write` shows the file it wrote, highlighted as that language, and accounts for what it hid.
///
/// It used to render the tool's *result* — a wall of green `+` rows capped at the model's token
/// budget, with no language to highlight and no honest count of what was cut.
#[test]
fn a_write_card_shows_its_content_and_admits_what_it_hid() {
let backend = test_backend(100, 40);
let mut app = create_app();
let content = (1..=30).map(|n| format!("let value_{n} = {n};")).collect::<Vec<_>>().join("\n");
let mut card = card_with_arguments(
"write",
"src/generated.rs",
serde_json::json!({"path": "src/generated.rs", "content": content}),
);
card.activity.output_preview = Some("Created 'src/generated.rs' (620 bytes)".into());
app.push_convo(ConvoBlock::Tool(Box::new(card)));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("write src/generated.rs"), "{rendered}");
assert!(rendered.contains("Created · 620 B"), "the header says what it did: {rendered}");
assert!(rendered.contains("1 let value_1 = 1;"), "content is numbered, not signed: {rendered}");
assert!(!rendered.contains("+1 let value_1"), "a write is not a wall of additions: {rendered}");
assert!(
rendered.contains("20 more lines · 30 total · click or ctrl+o to expand"),
"the footer accounts for the rest and names both ways in: {rendered}"
);
assert!(!rendered.contains("let value_11"), "the eleventh line is past the budget: {rendered}");
}
/// Ctrl+O opens every truncated card at once, and closes them again.
#[test]
fn toggling_tool_output_expands_every_card() {
let backend = test_backend(100, 60);
let mut app = create_app();
let content = (1..=20).map(|n| format!("line {n}")).collect::<Vec<_>>().join("\n");
app.push_convo(ConvoBlock::Tool(Box::new(card_with_arguments(
"write",
"notes.txt",
serde_json::json!({"path": "notes.txt", "content": content}),
))));
let collapsed = buffer_to_string(&render_app(&mut app, &backend));
assert!(collapsed.contains("10 more lines · 20 total"), "{collapsed}");
assert!(!collapsed.contains("line 20"));
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::CONTROL)));
let expanded = buffer_to_string(&render_app(&mut app, &backend));
assert!(expanded.contains("line 20"), "ctrl+o opened the card: {expanded}");
assert!(!expanded.contains("more lines"), "nothing left to account for: {expanded}");
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::CONTROL)));
let recollapsed = buffer_to_string(&render_app(&mut app, &backend));
assert!(recollapsed.contains("10 more lines · 20 total"), "and closed it again: {recollapsed}");
}
/// A multi-line `bash` command is shown in full, and the header stops trying to preview it.
#[test]
fn a_multiline_command_is_shown_under_its_card() {
let backend = test_backend(100, 30);
let mut app = create_app();
let command = "cd /tmp && python3 - <<'PY'\nimport json\nprint(json.dumps({'ok': True}))\nPY";
app.push_convo(ConvoBlock::Tool(Box::new(card_with_arguments(
"bash",
&luxe_core::describe_call("bash", &serde_json::json!({"command": command}), "/project"),
serde_json::json!({"command": command}),
))));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("print(json.dumps"), "the heredoc is no longer hidden: {rendered}");
assert!(
!rendered.contains("cd /tmp && python3 - <<'PY' …"),
"the header's ellipsized peek would sit directly above the real thing: {rendered}"
);
assert!(rendered.contains("cd /tmp && python3 - <<'PY'"), "which the body draws: {rendered}");
// A command is not a file, so it gets no line-number gutter.
assert!(!rendered.contains("2 import json"), "{rendered}");
// A one-liner says everything on its header already.
let mut single = create_app();
single.push_convo(ConvoBlock::Tool(Box::new(card_with_arguments(
"bash",
"cargo build",
serde_json::json!({"command": "cargo build"}),
))));
let one_line = buffer_to_string(&render_app(&mut single, &backend));
assert_eq!(one_line.matches("cargo build").count(), 1, "said once, not twice: {one_line}");
}
/// A `cd` into the directory the shell already starts in never reaches the card.
///
/// Most of what a model writes opens with one, and on a real project path it is fifty characters of
/// nothing in front of the command the reader came for — wide enough on a narrow card to push the
/// command off the end of the line. The sibling above proves the other half: a `cd` that actually
/// goes somewhere is kept.
#[test]
fn a_card_drops_a_cd_into_the_directory_the_command_already_ran_in() {
let backend = test_backend(100, 30);
let root = "/home/dev/project";
let command = format!("cd {root} && cargo build --workspace");
let mut app = create_app();
app.push_convo(ConvoBlock::Tool(Box::new(card_with_arguments(
"bash",
&luxe_core::describe_call("bash", &serde_json::json!({ "command": command }), root),
serde_json::json!({ "command": command }),
))));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("cargo build --workspace"), "the command survives: {rendered}");
assert!(!rendered.contains("cd "), "and the no-op does not: {rendered}");
}
/// A wide card draws its diff side by side; a narrow one stacks. Same rows, same numbers.
#[test]
fn a_card_diff_splits_when_wide_and_stacks_when_narrow() {
let preview = "Applied 1 edit(s) to 'src/lib.rs'\n ...\n 11 fn main() {\n\
-12 let label: String = category.to_string();\n\
+12 let label = category.display_name();\n 13 }";
let card = |width: u16| {
let mut app = create_app();
let mut edit = ToolActivity::running("session-a", "call-edit", "edit", "src/lib.rs", 1);
edit.state = ToolActivityState::Succeeded;
edit.output_preview = Some(preview.into());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: edit,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
buffer_to_string(&render_app(&mut app, &test_backend(width, 24)))
};
// 197 columns is a full-screen terminal; the rule puts old beside new on one row.
let wide = card(197);
let paired =
wide.lines().find(|line| line.contains("category.to_string")).expect("the replacement row");
assert!(paired.contains('│'), "a rule divides the columns: {paired:?}");
assert!(
paired.contains("category.display_name"),
"old and new share one row when wide: {paired:?}"
);
// At 100 columns each side would hold half a line of Rust, so it stacks instead.
let narrow = card(100);
let removed =
narrow.lines().find(|line| line.contains("category.to_string")).expect("the removal");
assert!(!removed.contains("display_name"), "a narrow card stacks: {removed:?}");
assert!(narrow.contains("-12") && narrow.contains("+12"), "both rows are there: {narrow}");
}
/// A tab-indented file draws on the same columns as a space-indented one, down to the buffer.
///
/// `unicode-width` scores a tab nothing and the terminal advances it to a stop, so a card that let
/// one through laid its columns out against a width the screen did not agree with. The rule stepped
/// right once per level of indentation, and the surplus pushed the row past the card — where the
/// transcript's word wrap broke it at a space, dropped the leading padding, and stranded the tail at
/// the left margin: an addition drawn inside the column reserved for removals, with no gutter and no
/// continuation marker to say what it was.
///
/// Through the real render path, because that is where the two measurements meet: the card lays a
/// row out, and the transcript wraps whatever the card handed it.
#[test]
fn a_tab_indented_card_diff_draws_on_the_columns_it_was_laid_out_for() {
// Svelte markup, tab-indented the way prettier writes it. Every tab starts on a stop, so the
// space-indented twin below is the same file once the tabs are spent.
const TABBED: &str = concat!(
"Applied 1 edit(s) to 'TopbarProfileMenu.svelte'\n",
" 415 \t\t\t<GettingStartedChecklist onCloseDrawer={closeDrawer} />\n",
" 416 \t\t\t</div>\n",
"-417 \t\t\t<!-- Tour launcher (desktop only, mobile needs its own tour) -->\n",
"-418 \t\t\t<div class=\"shrink-0 px-2.5 pb-1 max-sm:hidden\">\n",
"-419 \t\t\t\t<button type=\"button\" onclick={() => tourStore.startTour()}>\n",
"+417 \t\t\t<!-- Tour launcher (desktop only, mobile needs its own tour). -->\n",
"+418 \t\t\t<!-- Hidden while tourStore.isEnabled is false (see tour-store.svelte.ts). -->\n",
"+419 \t\t\t{#if tourStore.isEnabled}",
);
let card = |preview: &str| {
let mut app = create_app();
let mut edit =
ToolActivity::running("session-a", "call-edit", "edit", "TopbarProfileMenu.svelte", 1);
edit.state = ToolActivityState::Succeeded;
edit.output_preview = Some(preview.to_string());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: edit,
expanded: true,
details_toggled: false,
waited_on_user_ms: 0,
})));
buffer_to_string(&render_app(&mut app, &test_backend(180, 30)))
};
let tabbed = card(TABBED);
assert_eq!(tabbed, card(&TABBED.replace('\t', " ")), "a tab is four cells or it is a bug");
// The card body: everything under the header, down to the blank line that ends the block.
let rows: Vec<&str> = tabbed.lines().collect();
let header = rows
.iter()
.position(|row| row.contains("TopbarProfileMenu.svelte"))
.expect("the card header");
let body: Vec<&str> =
rows[header + 1..].iter().copied().take_while(|row| !row.trim().is_empty()).collect();
assert!(body.len() >= 5, "the diff drew its rows: {tabbed}");
// Every row of a side-by-side body carries the rule, wrapped rows included — both columns are
// padded so it cannot be otherwise. A row without one is a row the transcript re-wrapped, which
// is the tail of one column left sitting at the margin in front of the other.
for row in &body {
assert!(row.contains('\u{2502}'), "a row escaped its column: {row:?}");
}
let columns: std::collections::HashSet<u16> =
body.iter().map(|row| column_of(row, "\u{2502}")).collect();
assert_eq!(columns.len(), 1, "the rule stepped with the indentation: {columns:?}");
}
/// `unified` is a real override: a wide card honors it.
#[test]
fn the_unified_preference_survives_a_wide_card() {
let config = Config {
diff: luxe_core::config::DiffConfig {
layout: Some(luxe_core::config::DiffLayout::Unified),
..Default::default()
},
..Default::default()
};
let mut app = create_app_with_config(config);
let mut edit = ToolActivity::running("session-a", "call-edit", "edit", "src/lib.rs", 1);
edit.state = ToolActivityState::Succeeded;
edit.output_preview = Some(" 11 fn main() {\n-12 old();\n+12 new();\n 13 }".into());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: edit,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let rendered = buffer_to_string(&render_app(&mut app, &test_backend(197, 24)));
let removed = rendered.lines().find(|line| line.contains("old();")).expect("the removal");
assert!(!removed.contains("new();"), "unified means unified, even at 197 columns: {removed:?}");
}
/// The footer advertises expansion, so the advertised path has to work: select a card, open it.
///
/// Goes through the production event, because a card's identity comes from the activity projection —
/// and per-card expansion keys off exactly that identity.
#[test]
fn selecting_a_card_by_keyboard_and_opening_it_works() {
let backend = test_backend(100, 40);
let mut app = create_app();
app.update(Msg::Engine(luxe_core::event::Event::SessionLoaded {
session_id: "session-a".into(),
messages: Vec::new(),
}));
let content = (1..=20).map(|n| format!("line {n}")).collect::<Vec<_>>().join("\n");
let card = card_with_arguments(
"write",
"notes.txt",
serde_json::json!({"path": "notes.txt", "content": content}),
);
app.update(Msg::Engine(luxe_core::event::Event::ToolActivityUpdated(Box::new(card.activity))));
// Alt+K was bound to "select block up" and dispatched by nobody, so this was unreachable.
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::ALT)));
assert_eq!(app.selected_block, Some(0), "the card is selected");
// A selected card is still a card: the band it is drawn in survives the highlight, which is
// what tells a reader it is a tool call at all.
let buffer = render_app(&mut app, &backend);
let selected_bg = app.theme_styles.selected_bg.bg.expect("a selection background");
let header = (0..40)
.find(|&y| row_text(&buffer, y, 100).contains("write notes.txt"))
.expect("the card header renders");
assert_eq!(buffer[(2, header)].bg, selected_bg, "the band takes the selection tint");
assert_eq!(
buffer[(90, header)].bg,
selected_bg,
"and still runs the full width of the card, inset and all"
);
let pad = header.checked_sub(1).expect("a padding row above the header");
assert_eq!(buffer[(2, pad)].bg, selected_bg, "including its padding rows");
app.update(Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("line 20"), "the card opened: {rendered}");
}
/// A rejected edit produced no diff, so the card has to fall back to what the tool said — the
/// guard's own message — instead of rendering nothing but a header and a duration.
#[test]
fn a_rejected_edit_says_why_on_its_card() {
let (width, height) = (100, 24);
let backend = test_backend(width, height);
let mut app = create_app();
let mut edit = ToolActivity::running("session-a", "call-edit", "edit", "src/lib.rs", 1);
edit.state = ToolActivityState::Failed;
edit.summary = Some("edited before reading the file".into());
// A guard rejection is faster than the millisecond clock, which is exactly the case that used
// to read as "nothing happened".
edit.elapsed_ms = Some(0);
edit.output_preview = Some(
"Error: read 'src/lib.rs' before editing it (read-before-edit guard). Use the `read` \
tool first, then retry."
.into(),
);
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: edit,
expanded: true,
details_toggled: false,
waited_on_user_ms: 0,
})));
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("edited before reading"), "the card names the reason: {content}");
assert!(content.contains("read-before-edit guard"), "and shows the tool's words: {content}");
assert!(content.contains("<1ms"), "a sub-millisecond call says so: {content}");
assert!(!content.contains("0ms"), "never `0ms`, which reads as 'never ran': {content}");
}
/// A cancelled or failed turn must not silently start the queued follow-ups, and must not leave
/// them stuck behind a pending marker either — they come back to the composer instead.
///
/// Feeding a failing provider more turns compounds the failure, and a queue the user cannot see or
/// reach is worse still: the message is handed back where one key re-sends it.
#[test]
fn cancelling_or_failing_a_turn_returns_queued_messages_instead_of_running_them() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
for stop in ["cancel", "error"] {
let (tx, mut rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
app.editor.insert_text("follow-up work");
app.update(Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT)));
assert_eq!(app.queued_count(), 1, "{stop}: queued");
let _ = rx.try_recv(); // drain nothing-expected
match stop {
"cancel" => app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::Cancel)),
_ => app.update(Msg::Engine(luxe_core::event::Event::Error("provider down".into()))),
}
assert_eq!(app.queued_count(), 0, "{stop}: nothing is left waiting");
assert!(
!matches!(rx.try_recv(), Ok(luxe_core::engine::Action::SubmitUserMessage { .. })),
"{stop}: nothing was promoted"
);
assert_eq!(
app.editor.current_input(),
"follow-up work",
"{stop}: the message is back in the composer"
);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(!content.contains("queued #"), "{stop}: and the tray row is gone: {content}");
}
}
/// Dragging past the transcript's edges scrolls it; straying sideways does not.
#[test]
fn dragging_past_the_transcript_edge_scrolls_but_sideways_does_not() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (160, 16);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("drag-edges"));
for index in 0..40 {
app.push_convo(ConvoBlock::System(format!("line {index}")));
}
let buffer = render_app(&mut app, &backend);
// Start a drag on a transcript row (the transcript sits right of the dock rail).
let transcript_x = width - 10;
let first_row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("line "))
.expect("the transcript renders");
let event = |kind, column, row| MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let action = route_mouse(
&mut app,
&event(MouseEventKind::Down(MouseButton::Left), transcript_x, first_row + 1),
);
apply(&mut app, action);
assert!(app.pointer.selection_drag.is_some(), "the press anchored a transcript selection");
// Sideways over the dock rail: no scroll.
let before = app.scroll_state.offset;
let action =
route_mouse(&mut app, &event(MouseEventKind::Drag(MouseButton::Left), 2, first_row + 1));
apply(&mut app, action);
assert_eq!(app.scroll_state.offset, before, "a sideways drag must not scroll");
// Above the top row: scrolls up.
let action =
route_mouse(&mut app, &event(MouseEventKind::Drag(MouseButton::Left), transcript_x, 0));
apply(&mut app, action);
assert!(app.scroll_state.offset < before, "dragging above the pane scrolls up");
}
/// A copy confirms itself on screen, and the terminal's copy chords reach that path when the
/// terminal passes them through (it only holds them back when *it* has a selection).
#[test]
fn a_copy_is_confirmed_above_the_prompt_and_bound_to_the_terminal_copy_chords() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (80, 14);
let backend = test_backend(width, height);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("alpha bravo charlie".into()));
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("alpha bravo charlie"))
.expect("the reply renders");
let start_col = column_of(&row_text(&buffer, row, width), "bravo");
// Ctrl+Insert (what Hyprland's Super+C lowers to) copies the live selection.
let event = |kind, column| MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let action = route_mouse(&mut app, &event(MouseEventKind::Down(MouseButton::Left), start_col));
apply(&mut app, action);
let action =
route_mouse(&mut app, &event(MouseEventKind::Drag(MouseButton::Left), start_col + 5));
apply(&mut app, action);
app.update(Msg::Key(KeyEvent::new(KeyCode::Insert, KeyModifiers::CONTROL)));
render_app(&mut app, &backend);
assert_eq!(app.outbox.copy.as_deref(), Some("bravo"), "ctrl+insert copies the selection");
// …and the row above the prompt says so, because a captured drag leaves the terminal nothing to
// show. Right-aligned, on its own chip, out of the activity bar's way.
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
let toast = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Copied to clipboard"))
.unwrap_or_else(|| panic!("the copy is confirmed on screen: {content}"));
let text = row_text(&buffer, toast, width);
assert!(text.trim_end().ends_with("Copied to clipboard"), "right-aligned: {text:?}");
let chip = app.theme_styles.selected_bg.bg.expect("a chip background");
// Flush to the composer's own right margin, and wearing a bold accent on a background so it
// catches an eye on its way to the prompt.
assert_eq!(buffer[(width - 2, toast)].bg, chip, "the chip runs to the inset right edge");
let start = text.find('\u{f0c5}').expect("the clipboard glyph") as u16;
assert_eq!(buffer[(start, toast)].bg, chip);
assert_ne!(buffer[(start - 2, toast)].bg, chip, "and stops there");
let label = text.find("Copied").expect("the label") as u16;
assert!(buffer[(label, toast)].modifier.contains(ratatui::style::Modifier::BOLD));
assert_eq!(buffer[(label, toast)].fg, app.theme_styles.accent.fg.expect("the accent"));
// It is transient: a few seconds later the row is its old self again.
app.status.toast = app.status.toast.take().map(|(message, _)| {
(message, std::time::Instant::now() - std::time::Duration::from_secs(30))
});
let buffer = render_app(&mut app, &backend);
assert!(!buffer_to_string(&buffer).contains("Copied to clipboard"), "the toast expires");
// Ctrl+Shift+C is the other conventional chord and reaches the same action.
app.outbox.copy = None;
app.update(Msg::Key(KeyEvent::new(
KeyCode::Char('c'),
KeyModifiers::CONTROL | KeyModifiers::SHIFT,
)));
render_app(&mut app, &backend);
assert_eq!(app.outbox.copy.as_deref(), Some("bravo"));
}

View File

@@ -0,0 +1,405 @@
//! Changes — the dock list, the changes pane and the statusline module.
use super::*;
/// An app whose engine channel is *kept*, so a test can read the actions the UI sends and answer
/// them the way the engine would.
pub(super) fn create_app_with_engine(
) -> (App, tokio::sync::mpsc::Receiver<luxe_core::engine::Action>) {
let (tx, rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
(App::new(tx, KeyMap::defaults(), Config::default()), rx)
}
/// A workspace with `count` changed files, biggest first, in distinct directories.
pub(super) fn changed_workspace(scope: &str, count: usize) -> WorkspaceSnapshot {
let mut snapshot = empty_workspace(scope);
let files: Vec<FileChangeSummary> = (0..count)
.map(|index| FileChangeSummary {
path: format!("src/module{index:02}/file{index:02}.rs").into(),
status: FileChangeStatus::Modified,
additions: Some((count - index) as u64),
deletions: Some(0),
binary: false,
})
.collect();
snapshot.changes = WorkspaceChangesSummary {
total_files: files.len(),
additions: Some(files.iter().filter_map(|file| file.additions).sum()),
deletions: Some(0),
files,
truncated: false,
};
snapshot
}
/// One replaced line, as the review's content model represents it.
pub(super) fn one_hunk_file(path: &str) -> luxe_core::guided_review::ReviewFile {
use luxe_core::guided_review::{
FileId, HunkId, LineRange, NoiseKind, ReviewFile, ReviewFileStatus, ReviewHunk,
};
let id = FileId::from_path_lineage(
Some(std::path::Path::new(path)),
Some(std::path::Path::new(path)),
);
let line = |old, new, kind, text: &str| ReviewLine {
old_line: old,
new_line: new,
kind,
text: text.into(),
};
ReviewFile {
id: id.clone(),
old_path: Some(path.into()),
new_path: Some(path.into()),
status: ReviewFileStatus::Modified,
language: Some("rs".into()),
additions: Some(1),
deletions: Some(1),
hunks: vec![ReviewHunk {
id: HunkId::from_content(&id, "h", "h"),
old_range: LineRange::new(1, 2),
new_range: LineRange::new(1, 2),
heading: None,
symbol: None,
lines: vec![
line(Some(1), Some(1), ReviewLineKind::Context, "fn sum() {"),
line(Some(2), None, ReviewLineKind::Deletion, "let total = a + b;"),
line(None, Some(2), ReviewLineKind::Addition, "let total = a - b;"),
],
noise: NoiseKind::Semantic,
}],
binary: false,
generated: false,
non_text: None,
}
}
/// Opens `path` and answers the capture the UI asks for, the way the engine would.
pub(super) fn open_changes_with(
app: &mut App,
rx: &mut tokio::sync::mpsc::Receiver<luxe_core::engine::Action>,
path: &str,
file: Option<luxe_core::guided_review::ReviewFile>,
) {
app.update(Msg::OpenChanges(path.to_string()));
let request_id = loop {
match rx.try_recv().expect("the pane asks the engine for the diff") {
luxe_core::engine::Action::LoadFileDiff { request_id, path: asked } => {
assert_eq!(asked, path, "it asks for the file it is showing");
break request_id;
}
_ => continue,
}
};
app.update(Msg::Engine(luxe_core::event::Event::FileDiffLoaded {
request_id,
diff: Box::new(luxe_core::file_diff::FileDiff {
path: path.to_string(),
file: file.map(Box::new),
untracked: false,
}),
}));
}
/// Whether the diff row carrying `needle` is drawn as two columns.
///
/// Asked of the row rather than the screen: a bare `│` also draws the scrollbar rail and the
/// composer's own border, so a whole-buffer search for the rule finds one whether or not the diff
/// has two columns.
pub(super) fn split_row(buffer: &Buffer, needle: &str, app: &App, width: u16, height: u16) -> bool {
let row = row_containing(buffer, needle, width, height);
peek_diff_text(buffer, row, app, width).contains(" │ ")
}
/// One row of the peeked diff's own columns.
///
/// Scoped, because with the conversation kept beside it every row also carries the rule between
/// the two panes and whatever the transcript put after it.
pub(super) fn peek_diff_text(buffer: &Buffer, y: u16, app: &App, width: u16) -> String {
row_text(buffer, y, luxe_tui::view::peek_diff_column(app, width).unwrap_or(width))
}
/// Screen row of the first line containing `needle`.
pub(super) fn row_containing(buffer: &Buffer, needle: &str, width: u16, height: u16) -> u16 {
(0..height)
.find(|&y| row_text(buffer, y, width).contains(needle))
.unwrap_or_else(|| panic!("no rendered row contains {needle:?}"))
}
/// Screen row of the first *dock* line containing `needle`.
///
/// Scoped to the rail's own columns because the pane beside it shows the same file name in its
/// header, and a whole-row search finds whichever is drawn first.
pub(super) fn dock_row_containing(buffer: &Buffer, needle: &str, height: u16) -> u16 {
let rail = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
(0..height)
.find(|&y| row_text(buffer, y, rail).contains(needle))
.unwrap_or_else(|| panic!("no dock row contains {needle:?}"))
}
pub(super) fn left_click(app: &mut App, column: u16, row: u16) -> RouteAction {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
route_mouse(
app,
&MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column,
row,
modifiers: KeyModifiers::NONE,
},
)
}
pub(super) fn wheel_down(app: &mut App, column: u16, row: u16) -> RouteAction {
use crossterm::event::{MouseEvent, MouseEventKind};
route_mouse(
app,
&MouseEvent {
kind: MouseEventKind::ScrollDown,
column,
row,
modifiers: KeyModifiers::NONE,
},
)
}
/// The whole point of listing names: a click on one asks what it did to that file.
#[test]
fn clicking_a_dock_change_row_opens_that_files_diff() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("dock-change-click", 3));
let buffer = render_app(&mut app, &backend);
let row = dock_row_containing(&buffer, "file00.rs", height);
match left_click(&mut app, 5, row) {
RouteAction::Msg(message) => assert!(
matches!(&*message, Msg::OpenProjectFile(path) if path == "src/module00/file00.rs"),
"expected the clicked file's path, got {message:?}"
),
other => panic!("expected a diff to open from the click, got {other:?}"),
}
}
/// The gesture that opened the pane puts it away, so one row is one control rather than a trap.
#[test]
fn clicking_the_open_file_again_closes_the_pane() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("dock-change-toggle", 3));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
let row = dock_row_containing(&buffer, "file00.rs", height);
match left_click(&mut app, 5, row) {
RouteAction::Msg(message) => {
assert!(matches!(*message, Msg::CloseChanges), "a second click closes it")
}
other => panic!("expected the pane to close, got {other:?}"),
}
}
/// A change bigger than the dock's budget is still entirely reachable: the section scrolls inside
/// its own viewport instead of truncating, and a bar in its own lane says where you are in it.
#[test]
fn every_changed_file_is_reachable_by_scrolling_the_dock_list() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("dock-change-scroll", 24));
let buffer = render_app(&mut app, &backend);
let first = buffer_to_string(&buffer);
assert!(first.contains("file00.rs"), "the biggest change leads: {first}");
assert!(!first.contains("file23.rs"), "and the smallest is below the fold");
// The bar replaced the words: no scroll-position prose, and the thumb is against the top.
for prose in ["more below", "scroll here", " above", "not listed"] {
assert!(!first.contains(prose), "the lane says it instead of {prose:?}: {first}");
}
let lane = dock_scroll_lane(&buffer, "file00.rs", height);
assert_eq!(lane.first().copied(), Some(THUMB), "the thumb starts at the top: {lane:?}");
assert_eq!(lane.last().copied(), Some(TRACK), "and there is track below it: {lane:?}");
// Scroll until the last file arrives, bounded so a broken clamp fails instead of hanging.
let mut reached = false;
for _ in 0..40 {
app.update(Msg::ScrollDockList { list: DockList::Files, up: false });
if buffer_to_string(&render_app(&mut app, &backend)).contains("file23.rs") {
reached = true;
break;
}
}
assert!(reached, "every changed file is reachable by scrolling");
let buffer = render_app(&mut app, &backend);
let lane = dock_scroll_lane(&buffer, "file23.rs", height);
assert_eq!(lane.last().copied(), Some(THUMB), "the thumb followed to the end: {lane:?}");
assert_eq!(lane.first().copied(), Some(TRACK), "leaving track behind it: {lane:?}");
}
/// The dock's scrollbar lane: the track glyph, the thumb, and the column they share.
pub(super) const TRACK: char = '\u{2595}';
pub(super) const THUMB: char = '\u{2590}';
/// The lane beside the dock list containing `needle`, top to bottom.
///
/// Found from the row the list is on rather than from a fixed column, so the test fails on a lane
/// that moved rather than silently reading whatever is at column forty.
pub(super) fn dock_scroll_lane(buffer: &Buffer, needle: &str, height: u16) -> Vec<char> {
let rail = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
let column = (0..rail)
.rev()
.find(|&x| {
let glyph = buffer[(x, dock_row_containing(buffer, needle, height))].symbol();
glyph == TRACK.to_string() || glyph == THUMB.to_string()
})
.unwrap_or_else(|| panic!("no scrollbar lane on the row carrying {needle:?}"));
(0..height)
.map(|y| buffer[(column, y)].symbol().chars().next().unwrap_or(' '))
.filter(|glyph| *glyph == TRACK || *glyph == THUMB)
.collect()
}
/// A checklist longer than the rail is the same kind of surface: a lane beside it, the wheel over
/// it moving it, and every todo reachable.
///
/// The bar starts where the *work in hand* is rather than at the top, because that is the row a
/// reader is looking for; scrolling takes the list over, and scrolling back hands it to the plan
/// again.
#[test]
fn the_plan_scrolls_under_its_own_bar_and_goes_back_to_following_the_work() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(planned_workspace("dock-plan-scroll", 20, 14));
let buffer = render_app(&mut app, &backend);
let first = buffer_to_string(&buffer);
assert!(first.contains("step 14"), "the row in hand is in view: {first}");
assert!(!first.contains("step 00"), "the history above it is not");
assert!(!first.contains("earlier"), "and the lane says so instead of a count: {first}");
let lane = dock_scroll_lane(&buffer, "step 14", height);
assert!(lane.contains(&THUMB) && lane.contains(&TRACK), "a real bar: {lane:?}");
assert_eq!(lane.first().copied(), Some(TRACK), "parked past the top, on the work: {lane:?}");
// The wheel over the checklist moves the checklist, not the panel.
let row = dock_row_containing(&buffer, "step 14", height);
match wheel_down(&mut app, 5, row) {
RouteAction::Msg(message) => {
assert!(
matches!(*message, Msg::ScrollDockList { list: DockList::Plan, up: false }),
"over the checklist, the wheel moves the checklist: {message:?}"
);
app.update(*message);
}
other => panic!("expected the checklist to scroll, got {other:?}"),
}
let scrolled = buffer_to_string(&render_app(&mut app, &backend));
assert!(scrolled.contains("step 19"), "the tail is reachable: {scrolled}");
// Back to the top, then back down to the work: the plan is following again.
for _ in 0..20 {
app.update(Msg::ScrollDockList { list: DockList::Plan, up: true });
}
let top = buffer_to_string(&render_app(&mut app, &backend));
assert!(top.contains("step 00"), "every todo is reachable: {top}");
for _ in 0..20 {
app.update(Msg::ScrollDockList { list: DockList::Plan, up: false });
}
let bottom = buffer_to_string(&render_app(&mut app, &backend));
assert!(bottom.contains("step 19"), "and the far end too: {bottom}");
}
/// A checklist that fits carries no lane at all — a bar on a complete list claims there is more.
#[test]
fn a_plan_that_fits_the_rail_has_no_bar() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(planned_workspace("dock-plan-short", 4, 2));
let buffer = render_app(&mut app, &backend);
let rail = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
let row = dock_row_containing(&buffer, "step 02", height);
assert!(
(0..rail).all(|x| ![TRACK.to_string(), THUMB.to_string()]
.contains(&buffer[(x, row)].symbol().to_string())),
"a complete checklist draws no lane: {}",
row_text(&buffer, row, rail)
);
// And the wheel over it belongs to the panel again.
match wheel_down(&mut app, 5, row) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::ScrollDock { up: false }),
"nothing to scroll in the section, so the panel moves: {message:?}"
),
other => panic!("expected the panel to scroll, got {other:?}"),
}
}
/// A session whose checklist is longer than the rail, with `active` in progress and everything
/// before it done.
pub(super) fn planned_workspace(scope: &str, count: usize, active: usize) -> WorkspaceSnapshot {
let mut snapshot = empty_workspace(scope);
let items: Vec<TodoSummaryItem> = (0..count)
.map(|index| TodoSummaryItem {
id: index.to_string(),
subject: format!("step {index:02}"),
status: match index.cmp(&active) {
std::cmp::Ordering::Less => TodoSummaryStatus::Completed,
std::cmp::Ordering::Equal => TodoSummaryStatus::InProgress,
std::cmp::Ordering::Greater => TodoSummaryStatus::Pending,
},
blocked_by: Vec::new(),
})
.collect();
snapshot.todos = TodoSummary {
current: items.get(active).cloned(),
pending: count.saturating_sub(active + 1),
in_progress: 1,
completed: active,
blocked: 0,
total: count,
truncated: false,
items,
};
snapshot
}
/// Two scroll regions, one panel: the wheel over the file list moves the list, and the wheel
/// anywhere else in the dock moves the panel. Without the distinction the list could never be
/// bounded *and* complete.
#[test]
fn the_wheel_moves_the_change_list_over_it_and_the_panel_elsewhere() {
let (width, height) = (160, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("dock-scroll-regions", 24));
let buffer = render_app(&mut app, &backend);
let over_list = dock_row_containing(&buffer, "file00.rs", height);
let over_heading = dock_row_containing(&buffer, "PROJECT", height);
match wheel_down(&mut app, 5, over_list) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::ScrollDockList { list: DockList::Files, up: false }),
"over the list, the wheel moves the list: {message:?}"
),
other => panic!("expected the list to scroll, got {other:?}"),
}
match wheel_down(&mut app, 5, over_heading) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::ScrollDock { up: false }),
"elsewhere it moves the panel: {message:?}"
),
other => panic!("expected the panel to scroll, got {other:?}"),
}
}

View File

@@ -0,0 +1,519 @@
//! Changes pane — the peeked diff, its columns, footer and stepping.
use super::*;
/// The pane takes the conversation column and gives it back — the dock and the composer never
/// move, which is what makes the dock usable as the pane's navigation.
#[test]
fn the_changes_pane_replaces_the_transcript_and_esc_returns_it() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("changes-pane", 3));
app.push_convo(ConvoBlock::Assistant("a distinctive transcript line".into()));
let transcript = buffer_to_string(&render_app(&mut app, &backend));
assert!(transcript.contains("a distinctive transcript line"));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let pane = buffer_to_string(&render_app(&mut app, &backend));
assert!(!pane.contains("a distinctive transcript line"), "the pane owns the column: {pane}");
assert!(pane.contains("file00.rs"), "and names the file: {pane}");
assert!(pane.contains("FILES"), "the dock stays: {pane}");
assert!(pane.contains("esc close"), "and says how to leave: {pane}");
app.update(Msg::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)));
let back = buffer_to_string(&render_app(&mut app, &backend));
assert!(back.contains("a distinctive transcript line"), "Esc gives the column back: {back}");
}
/// The pane draws the file's actual hunks, through the review's own content model.
#[test]
fn the_changes_pane_draws_the_hunks_it_was_given() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("changes-hunks", 2));
app.update(Msg::OpenChanges("src/module00/file00.rs".into()));
let loading = buffer_to_string(&render_app(&mut app, &backend));
assert!(loading.contains("Reading the change"), "it says it is working: {loading}");
let path = "src/module00/file00.rs";
// Re-open through the helper so the request the pane is waiting on is the one answered.
app.update(Msg::CloseChanges);
while rx.try_recv().is_ok() {}
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert!(shown.contains("@@ -1,2 +1,2 @@"), "the hunk header orients the reader: {shown}");
assert!(shown.contains("let total = a + b;"), "the old line: {shown}");
assert!(shown.contains("let total = a - b;"), "and the new one: {shown}");
assert!(shown.contains("1 of 2"), "and where this file sits in the change: {shown}");
}
/// A file that matches its base is an answer, not a failure — and never an empty surface.
#[test]
fn an_unchanged_file_says_so_rather_than_showing_nothing() {
let (width, height) = (120, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("changes-clean", 2));
open_changes_with(&mut app, &mut rx, "src/module00/file00.rs", None);
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert!(shown.contains("Nothing has changed in this file"), "{shown}");
}
/// A failure is shown as a sentence a person can act on, in the pane they are looking at.
#[test]
fn a_failed_capture_is_reported_in_the_pane() {
let (width, height) = (120, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("changes-failure", 2));
let path = "src/module00/file00.rs";
app.update(Msg::OpenChanges(path.to_string()));
let luxe_core::engine::Action::LoadFileDiff { request_id, .. } =
rx.try_recv().expect("a capture was requested")
else {
panic!("expected a file-diff request");
};
app.update(Msg::Engine(luxe_core::event::Event::FileDiffFailed {
request_id,
path: path.to_string(),
error: luxe_core::file_diff::FileDiffFailure::TooLarge,
}));
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert!(shown.contains("This change is too large"), "capitalized like prose: {shown}");
assert!(shown.contains("open the full review"), "and says where to go instead: {shown}");
}
/// Escalating leaves the pane and asks for a review — the expensive surface, deliberately.
///
/// Asking is all it does: the review opens once there is a whole one to open, and until then the
/// tray above the composer carries the wait.
#[test]
fn escalating_from_the_pane_opens_the_review() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("changes-escalate", 2));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let _ = render_app(&mut app, &backend);
app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::ReviewOpen));
let asked = std::iter::from_fn(|| rx.try_recv().ok())
.any(|action| matches!(action, luxe_core::engine::Action::LoadGuidedReview { .. }));
assert!(asked, "a review capture was requested");
assert_eq!(app.current_view, ViewMode::Chat, "and the screen is not taken until it is ready");
let waiting = buffer_to_string(&render_app(&mut app, &backend));
assert!(waiting.contains("review"), "with the wait visible where the reader is: {waiting}");
}
/// The bar's changes module earns its cells by carrying the way in, not just the number.
#[test]
fn the_statusline_changes_module_says_the_count_and_the_key() {
let (width, height) = (150, 24);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("statusline-changes", 4));
app.dock.hide();
app.statusline_state.show();
let buffer = render_app(&mut app, &backend);
let bar = row_text(&buffer, height - 1, width);
assert!(bar.contains("4 files"), "the count: {bar}");
assert!(bar.contains("ctrl+p"), "and how to see them: {bar}");
// Clicking it is the same affordance for the pointer already sitting on it.
let column = column_of(&bar, "4 files");
match left_click(&mut app, column, height - 1) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::DispatchUiAction(luxe_core::keymap::UiAction::ToggleChanges)),
"clicking the module opens the pane: {message:?}"
),
other => panic!("expected the module to be clickable, got {other:?}"),
}
}
/// A clean worktree spends no cells saying so.
#[test]
fn the_statusline_changes_module_is_absent_with_nothing_changed() {
let (width, height) = (150, 24);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("statusline-clean"));
app.dock.hide();
app.statusline_state.show();
let bar = row_text(&render_app(&mut app, &backend), height - 1, width);
assert!(!bar.contains("files"), "no change, no module: {bar}");
assert!(!bar.contains("ctrl+p"), "and no key to advertise: {bar}");
}
/// A peeked diff keeps the conversation beside it where the column can seat both — and the whole
/// chat stack, composer included, narrows with it.
///
/// A prompt spanning both columns says the text goes to both, which is not what happens: the
/// message lands in the transcript. And a diff stopping short of the composer's rows would waste
/// them for nothing.
#[test]
fn a_peeked_diff_keeps_the_conversation_and_the_composer_beside_it() {
let path = "src/module00/file00.rs";
let (width, height) = (240u16, 30);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("peek-three-pane", 2));
app.push_convo(ConvoBlock::Assistant("A reply that stays readable beside the code.".into()));
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
let diff_width = luxe_tui::view::peek_diff_column(&app, width).expect("the column seats both");
let whole = buffer_to_string(&buffer);
assert!(whole.contains("fn sum() {"), "the diff is on screen: {whole}");
assert!(whole.contains("stays readable beside the code"), "and so is the exchange: {whole}");
// The composer belongs to the conversation column: its box starts to the right of the diff.
let composer_row = row_containing(&buffer, "\u{256d}", width, height);
let left_of_rule = row_text(&buffer, composer_row, diff_width);
assert!(
!left_of_rule.contains('\u{256d}'),
"the prompt does not reach under the diff: {left_of_rule:?}"
);
// And the diff runs the full height beside it rather than stopping where the composer starts.
let footer_row = row_containing(&buffer, "esc close", width, height);
assert!(footer_row > composer_row, "the diff outlasts the prompt: {whole}");
}
/// On a wide terminal the diff takes what code needs and the conversation keeps the rest.
///
/// It used to be the other way round: the conversation was capped at eighty cells and a unified
/// diff took everything else, so a wide screen spent most of its rows on empty diff.
#[test]
fn a_wide_peek_gives_the_conversation_what_the_diff_does_not_need() {
use luxe_tui::view::peek_diff_width;
let unified = peek_diff_width(300, false).expect("seats both");
let split = peek_diff_width(300, true).expect("seats both");
assert!(unified < 140, "a unified diff stops at a code measure: {unified}");
assert!(split > unified && split < 230, "two columns get two measures: {split}");
assert_eq!(peek_diff_width(300, false), peek_diff_width(400, false), "and stops growing");
// Narrower than the caps, nothing changes: the transcript keeps its floor and the diff the rest
assert_eq!(peek_diff_width(140, false), Some(140 - 57));
assert_eq!(peek_diff_width(140, true), Some(140 - 57));
// Whether the two share never depends on the layout, so a layout toggle never moves the chat
for width in [128u16, 129, 200] {
assert_eq!(peek_diff_width(width, false).is_some(), peek_diff_width(width, true).is_some());
}
// On screen: a unified peek on a wide terminal, the transcript wide beside it
let path = "src/module00/file00.rs";
let (width, height) = (300u16, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("peek-wide", 2));
app.push_convo(ConvoBlock::Assistant("word ".repeat(60)));
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
render_app(&mut app, &backend);
assert_eq!(luxe_tui::view::peek_diff_column(&app, width), Some(split), "starts split");
// The toggle flips what the last frame drew
app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::ReviewToggleSplit));
let buffer = render_app(&mut app, &backend);
let diff = luxe_tui::view::peek_diff_column(&app, width).expect("shared");
assert_eq!(diff, unified, "drawn unified, sized unified");
let prose = row_containing(&buffer, "word word", width, height);
let words = row_text(&buffer, prose, width).matches("word").count();
assert!(words > 30, "the transcript has room for a line of prose: {words} words");
}
/// Below that width the diff takes the column alone, because a transcript in forty cells is a
/// column of two-word lines.
#[test]
fn a_narrow_peek_gives_the_diff_the_whole_column() {
let path = "src/module00/file00.rs";
let (width, height) = (110u16, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("peek-two-pane", 2));
app.push_convo(ConvoBlock::Assistant("A reply that has to wait its turn.".into()));
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
assert!(luxe_tui::view::peek_diff_width(width, false).is_none(), "too narrow for both");
let whole = buffer_to_string(&render_app(&mut app, &backend));
assert!(whole.contains("fn sum() {"), "the diff is on screen: {whole}");
assert!(!whole.contains("has to wait its turn"), "and the transcript waits: {whole}");
}
/// A pane with room for two readable columns draws two; one without draws the unified list. Nobody
/// has to ask for it, which is why the width test has to be conservative rather than eager.
#[test]
fn the_pane_draws_two_columns_only_where_they_would_read() {
let path = "src/module00/file00.rs";
// 260 rather than 200: with the conversation kept beside it, a diff needs the wider terminal
// before its own two columns fit. At 90 the pane has the main column to itself and still
// cannot seat two readable ones.
for (width, expect_split) in [(260u16, true), (90u16, false)] {
let backend = test_backend(width, 24);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height: 24 });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-split", 2));
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
assert_eq!(
split_row(&buffer, "fn sum() {", &app, width, 24),
expect_split,
"at {width} columns, split should be {expect_split}: {}",
buffer_to_string(&buffer)
);
// Either way the change itself is legible.
let shown = buffer_to_string(&buffer);
assert!(shown.contains("let total = a - b;"), "the new line is shown: {shown}");
}
}
/// One key, both diff surfaces: the action names a layout rather than a surface.
#[test]
fn the_layout_toggle_switches_the_pane_between_columns_and_the_list() {
// Wide enough for the diff to keep two columns beside the conversation the peek now keeps.
let (width, height) = (260, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-toggle-split", 2));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
assert!(
split_row(&buffer, "fn sum() {", &app, width, height),
"wide enough, so it starts split"
);
let split = buffer_to_string(&buffer);
assert!(split.contains("ctrl+b unified diff"), "and offers the other layout: {split}");
app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::ReviewToggleSplit));
let buffer = render_app(&mut app, &backend);
assert!(
!split_row(&buffer, "fn sum() {", &app, width, height),
"one press switches to the list"
);
let unified = buffer_to_string(&buffer);
assert!(unified.contains("ctrl+b side-by-side diff"), "and offers the way back: {unified}");
}
/// Stepping between files does not make the layout shortcut blink.
///
/// `ChangesView::show` drops the loaded diff and the next capture takes a frame, so anything that
/// asks "can this draw two columns?" through `view.file()` gets `None` in between. Answering
/// `false` there dropped the shortcut out of the footer and put it back a frame later — every hint
/// to its right shifted twice per file switch. The last resolved layout carries across the gap
/// instead, so the row holds still.
#[test]
fn stepping_between_files_holds_the_footer_still() {
let (width, height) = (200, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-footer-still", 2));
let first = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, first, Some(one_hunk_file(first)));
let footer_of = |app: &mut App| -> String {
let buffer = render_app(app, &backend);
let row = row_containing(&buffer, "esc close", width, height);
peek_diff_text(&buffer, row, app, width).trim().to_string()
};
let settled = footer_of(&mut app);
assert!(settled.contains("diff"), "precondition: the layout shortcut is on the row: {settled}");
// Mid-switch: the next diff has been asked for but has not arrived.
app.update(Msg::ChangesStepFile(true));
let loading = footer_of(&mut app);
assert_eq!(loading, settled, "the footer must not reflow while the next diff loads");
}
/// The left column is the old file and the right is the new one, so each numbers its own side.
/// Printing the old number beside new content is a false statement about where that line lives.
#[test]
fn each_split_column_numbers_its_own_side() {
// Wide enough for the diff to keep two columns beside the conversation the peek now keeps.
let (width, height) = (260, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-split-numbers", 2));
let path = "src/module00/file00.rs";
// Context at old 9 / new 4, so the two sides cannot be confused for one another.
let mut file = one_hunk_file(path);
file.hunks[0].lines[0].old_line = Some(9);
file.hunks[0].lines[0].new_line = Some(4);
open_changes_with(&mut app, &mut rx, path, Some(file));
let buffer = render_app(&mut app, &backend);
let row = row_containing(&buffer, "fn sum() {", width, height);
let text = peek_diff_text(&buffer, row, &app, width);
let (left, right) = text.split_once(" │ ").expect("a split row has two columns");
assert!(left.contains('9'), "the old column carries the old number: {left:?}");
assert!(right.contains('4'), "the new column carries the new one: {right:?}");
assert!(!right.contains('9'), "and not the old one: {right:?}");
}
/// A rule sits over the pane's shortcuts, the way one sits under its header: straight after the
/// last line of code, the keys read as one more line of it.
#[test]
fn the_pane_rules_off_its_footer() {
let path = "src/module00/file00.rs";
let (width, height) = (120u16, 20u16);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-rule", 3));
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
let row = row_containing(&buffer, "esc close", width, height);
let above = peek_diff_text(&buffer, row - 1, &app, width);
assert!(above.trim().chars().all(|c| c == '─') && above.trim().len() > 20, "{above:?}");
}
/// A footer that truncates mid-label is worse than one that says less: `Alt+W no wr` teaches the
/// reader that the row cannot be trusted.
#[test]
fn the_pane_footer_drops_whole_shortcuts_rather_than_truncating_one() {
let path = "src/module00/file00.rs";
for width in [50u16, 60, 70, 90, 120, 200] {
let backend = test_backend(width, 20);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height: 20 });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-footer", 3));
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
let row = row_containing(&buffer, "esc close", width, 20);
let footer = peek_diff_text(&buffer, row, &app, width);
assert!(
footer.trim_end().ends_with("esc close"),
"the way out is never the thing that gets cut, at {width}: {footer:?}"
);
// Every segment on the row is a whole shortcut, so nothing was cut mid-label.
const WHOLE: [&str; 9] = [
"alt+m whole file",
"alt+m changes",
"alt+n next file",
"alt+p previous",
"ctrl+b side-by-side diff",
"ctrl+b unified diff",
"alt+o open in editor",
"alt+w stop wrapping",
"ctrl+g review this file",
];
for segment in footer.trim().split(" · ") {
assert!(
segment == "esc close" || WHOLE.contains(&segment),
"{segment:?} is not a whole shortcut at {width}: {footer:?}"
);
}
}
}
/// A peek at a file outside the project says where it is, and stops short of a review.
///
/// The pane is the same pane, and the footer is where the difference has to show: a review is
/// captured from the project's own worktree, so `Ctrl+G review this file` over a file that lives
/// somewhere else names a destination that cannot exist.
#[test]
fn peeking_a_file_outside_the_project_offers_everything_but_the_review() {
let (width, height) = (140, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(external_workspace());
let path = "/work/sdk/src/client.ts";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("/work/sdk/src/client.ts"), "the header says where it is: {content}");
assert!(content.contains("esc close"), "the footer is drawn: {content}");
assert!(
!content.contains("review this file"),
"and offers no review of a file no review can contain: {content}"
);
}
/// Stepping walks every file this session changed, the project's own first and the rest after —
/// the list is what changed, and work done elsewhere changed too.
#[test]
fn stepping_runs_off_the_projects_changes_into_the_work_done_elsewhere() {
let (width, height) = (140, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
let mut workspace = changed_workspace("changes-stepping", 1);
workspace.external = external_workspace().external;
app.workspace = Some(workspace);
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
app.update(Msg::ChangesStepFile(true));
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("client.ts"), "the next file is the one elsewhere: {content}");
assert!(content.contains("2 of 2"), "and it is counted in the same list: {content}");
}
/// The pane cannot scroll sideways, so it wraps from the start: a clipped line here would put
/// content out of reach rather than one keystroke away.
#[test]
fn the_pane_wraps_long_lines_without_being_asked() {
let (width, height) = (120, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("changes-wrap", 2));
let path = "src/module00/file00.rs";
let mut file = one_hunk_file(path);
// One-sided, so the pane stays a unified list at any width: wrapping a *column* is the split
// renderer's own business, and the continuation and clipped forms below only exist here.
file.status = luxe_core::guided_review::ReviewFileStatus::Added;
let tail = "the-tail-that-must-not-be-lost";
file.hunks[0].lines[0].text = format!("let head = \"{}{tail}\";", "padding-".repeat(20));
open_changes_with(&mut app, &mut rx, path, Some(file));
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert!(shown.contains(tail), "the end of a long line is still reachable: {shown}");
assert!(shown.contains('↳'), "and it says where it continued: {shown}");
assert!(shown.contains("alt+w stop wrapping"), "the footer offers to stop wrapping: {shown}");
// Turning it off clips instead, and says so.
app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::ChangesToggleWordWrap));
let clipped = buffer_to_string(&render_app(&mut app, &backend));
assert!(!clipped.contains(tail), "clipped now: {clipped}");
assert!(clipped.contains('…'), "and marked as clipped: {clipped}");
}

View File

@@ -0,0 +1,207 @@
//! Chat keys — arrows, paging and the scroll state under them.
use super::*;
/// Plain arrows belong to the composer; modified arrows remain conversation bindings.
#[test]
fn test_route_key_chat_arrows_edit_the_composer() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::Chat;
app.editor.insert_text("alpha\nbeta");
match route_key(&mut app, &key(KeyCode::Up)) {
RouteAction::Msg(message) => app.update(*message),
action => panic!("plain Up did not reach the editor: {action:?}"),
}
assert_eq!(app.editor.visual_cursor(80).row, 0);
let alt_down = KeyEvent::new(KeyCode::Down, KeyModifiers::ALT);
assert!(matches!(
route_key(&mut app, &alt_down),
RouteAction::Msg(message) if matches!(*message, Msg::Key(_))
));
}
#[test]
fn open_palette_receives_arrow_keys_before_chat_scrolling() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.overlays.palette = Some(luxe_tui::palette::PaletteState::open(
luxe_tui::commands::CommandRegistry::all().arrange(
&luxe_tui::commands::CommandContext::default(),
&KeyMap::defaults(),
&[],
),
));
match route_key(&mut app, &key(KeyCode::Down)) {
RouteAction::Msg(message) => app.update(*message),
action => panic!("palette arrow leaked to chat routing: {action:?}"),
}
assert_eq!(app.overlays.palette.as_ref().map(|state| state.selected()), Some(1));
assert_eq!(app.scroll_state.offset, 0);
}
#[test]
fn test_route_key_chat_inserts_j_and_k() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::Chat;
for character in ['j', 'k'] {
match route_key(&mut app, &key(KeyCode::Char(character))) {
RouteAction::Msg(msg) => app.update(*msg),
action => panic!("expected editor input for {character:?}, got {action:?}"),
}
}
assert_eq!(app.editor.current_input(), "jk");
}
/// Page keys scroll the conversation without reserving printable editor keys.
#[test]
fn test_route_key_chat_page_scroll() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::Chat;
assert!(matches!(
route_key(&mut app, &key(KeyCode::PageUp)),
RouteAction::Scroll(luxe_tui::main_loop::ScrollAction::PageUp)
));
assert!(matches!(
route_key(&mut app, &key(KeyCode::PageDown)),
RouteAction::Scroll(luxe_tui::main_loop::ScrollAction::PageDown)
));
for character in ['b', 'f', 'G', 'y'] {
match route_key(&mut app, &key(KeyCode::Char(character))) {
RouteAction::Msg(message) => app.update(*message),
action => panic!("printable {character:?} was intercepted: {action:?}"),
}
}
assert_eq!(app.editor.current_input(), "bfGy");
}
#[test]
fn standard_paste_bindings_request_a_unified_clipboard_read() {
let mut app = create_app();
for paste_key in [
KeyEvent::new(KeyCode::Char('v'), KeyModifiers::CONTROL),
KeyEvent::new(KeyCode::Insert, KeyModifiers::SHIFT),
] {
app.outbox.clipboard_paste = false;
match route_key(&mut app, &paste_key) {
RouteAction::Msg(message) => app.update(*message),
action => panic!("standard paste did not reach App: {action:?}"),
}
assert!(app.outbox.clipboard_paste);
}
}
#[test]
fn test_route_key_chat_ctrl_end_scrolls_to_bottom() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::Chat;
let ctrl_end = KeyEvent::new(KeyCode::End, KeyModifiers::CONTROL);
assert!(matches!(
route_key(&mut app, &ctrl_end),
RouteAction::Scroll(luxe_tui::main_loop::ScrollAction::ToBottom)
));
}
/// Chat view: non-scroll keys still pass through as Msg::Key.
#[test]
fn test_route_key_chat_non_scroll_passes_through() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::Chat;
assert!(matches!(
route_key(&mut app, &key(KeyCode::Char('a'))),
RouteAction::Msg(message) if matches!(*message, Msg::Key(_))
));
assert!(matches!(
route_key(&mut app, &key(KeyCode::Char('/'))),
RouteAction::Msg(message) if matches!(*message, Msg::Key(_))
));
}
/// Scroll state: line_down moves offset by 1.
#[test]
fn test_scroll_state_new_starts_at_bottom() {
let scroll = luxe_tui::scroll::ScrollState::new(10, 100);
assert_eq!(scroll.offset, 90); // starts at bottom (100 - 10)
assert!(scroll.follow);
}
#[test]
fn test_scroll_state_line_up() {
let mut scroll = luxe_tui::scroll::ScrollState::new(10, 100);
scroll.follow = false;
scroll.line_up();
assert_eq!(scroll.offset, 89);
}
#[test]
fn test_scroll_state_page_down_at_bottom() {
let mut scroll = luxe_tui::scroll::ScrollState::new(10, 100);
scroll.follow = false;
scroll.offset = 50;
scroll.page_down();
assert_eq!(scroll.offset, 60); // moved down by 10
}
#[test]
fn test_scroll_state_to_bottom() {
let mut scroll = luxe_tui::scroll::ScrollState::new(10, 100);
scroll.offset = 50;
scroll.follow = false;
scroll.to_bottom();
assert_eq!(scroll.offset, 90);
assert!(scroll.follow);
}
#[test]
fn test_scroll_state_position_percent() {
let scroll = luxe_tui::scroll::ScrollState::new(10, 100);
assert_eq!(scroll.position_percent(), 100); // at bottom (90/90)
let mut scroll = luxe_tui::scroll::ScrollState::new(10, 100);
scroll.follow = false;
scroll.offset = 45;
assert_eq!(scroll.position_percent(), 50); // 45 / 90 = 50%
}
#[test]
fn test_scroll_state_window() {
let scroll = luxe_tui::scroll::ScrollState::new(10, 100);
let win = scroll.window();
assert_eq!(win.start, 90);
assert_eq!(win.end, 100);
}
#[test]
fn test_scroll_state_on_resize() {
let mut scroll = luxe_tui::scroll::ScrollState::new(10, 100);
scroll.follow = false;
scroll.offset = 80;
scroll.on_resize(20);
assert_eq!(scroll.viewport, 20);
assert_eq!(scroll.offset, 80); // within new bounds
}
#[test]
fn test_default_chat_omits_conversation_label() {
let backend = test_backend(80, 24);
let mut app = create_app();
let buffer = render_app(&mut app, &backend);
let top = row_text(&buffer, 0, 80);
assert!(!top.contains("Conversation"), "conversation label should be hidden: {top:?}");
assert!(!top.contains('%'), "scroll percentage should be hidden: {top:?}");
}

View File

@@ -0,0 +1,138 @@
//! Clicks — copy affordances, the composer cursor and prose that is not a button.
use super::*;
/// Each fenced code block renders a muted "copy" caption at its **top right**, where every editor
/// and every chat client puts one; clicking it copies the block's source text. It sits on
/// selectable text, so like every transcript click it acts on the release.
#[test]
fn clicking_a_code_block_copy_affordance_copies_the_code() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.push_convo(ConvoBlock::Assistant(
"Here is the answer:\n\n```rust\nlet answer = 42;\n```\n".into(),
));
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("copy"))
.expect("the code-block copy affordance renders");
let code = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("let answer = 42;"))
.expect("the code renders");
assert!(row < code, "the affordance is above the block, not a stray word under it");
// The block is framed: a rule above carrying the language and the copy affordance, a rule
// below, and the two ending on the same column so they read as one box. The frame may be
// *wider* than the code — a box around three words is still a box — but never narrower.
let last_column = |y: u16| {
(0..width).rev().find(|&x| buffer[(x, y)].symbol().trim() != "").expect("a drawn row")
};
let closing = (code + 1..height)
.find(|&y| row_text(&buffer, y, width).trim().starts_with('\u{2500}'))
.expect("the block is closed by a rule");
assert_eq!(
last_column(row),
last_column(closing),
"the frame's rules must line up: {:?} against {:?}",
row_text(&buffer, row, width).trim_end(),
row_text(&buffer, closing, width).trim_end(),
);
assert!(
last_column(row) >= last_column(code),
"the frame is at least as wide as what it frames: {:?}",
row_text(&buffer, row, width).trim_end(),
);
assert!(
row_text(&buffer, row, width).contains("rust"),
"the opening rule names the language: {:?}",
row_text(&buffer, row, width).trim_end(),
);
let column = last_column(row) - 1;
let event = |kind| MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
// The affordance sits on selectable text, so it acts on the release — a press there could
// still be the start of a drag.
assert!(matches!(
route_mouse(&mut app, &event(MouseEventKind::Down(MouseButton::Left))),
RouteAction::None
));
match route_mouse(&mut app, &event(MouseEventKind::Up(MouseButton::Left))) {
RouteAction::Msg(message) => match *message {
Msg::CopyText(text) => {
assert!(text.contains("let answer = 42;"), "copies the code text, got {text:?}")
}
other => panic!("expected a CopyText message, got {other:?}"),
},
other => panic!("expected a copy message from the click, got {other:?}"),
}
}
/// Editor click-to-cursor: clicking a cell in the composer places the cursor at that visual
/// position (the inverse of `visual_cursor`) — anchoring a selection there is what moves it.
#[test]
fn clicking_the_composer_places_the_cursor() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.editor.insert_text("hello world");
assert_eq!(app.editor.cursor(), 11, "cursor starts at the end of the inserted text");
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("hello world"))
.expect("the composer text renders");
// Click the 'w' of "world" (offset 6 in "hello world").
let wx = (0..width).find(|&x| buffer[(x, row)].symbol() == "w").expect("the 'w' cell renders");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: wx,
row,
modifiers: KeyModifiers::NONE,
};
// The press anchors a selection at that cell, which is what places the caret.
assert!(matches!(route_mouse(&mut app, &click), RouteAction::None));
assert_eq!(app.editor.cursor(), 6, "clicking the 'w' cell moves the cursor to offset 6");
}
/// A click on plain transcript prose neither selects nor copies the message: prose is there to be
/// read and dragged across, and a click that copies a whole message behind the reader's back was
/// the single least predictable thing the mouse did.
#[test]
fn clicking_transcript_prose_neither_selects_nor_copies_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.push_convo(ConvoBlock::User {
text: "first message".into(),
attached: Vec::new(),
chips: Vec::new(),
});
app.push_convo(ConvoBlock::Assistant("second message reply".into()));
app.push_convo(ConvoBlock::User {
text: "third message".into(),
attached: Vec::new(),
chips: Vec::new(),
});
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("second message"))
.expect("the second block renders");
let event = |kind| MouseEvent { kind, column: 10, row, modifiers: KeyModifiers::NONE };
for kind in [MouseEventKind::Down(MouseButton::Left), MouseEventKind::Up(MouseButton::Left)] {
let action = route_mouse(&mut app, &event(kind));
apply(&mut app, action);
}
assert_eq!(app.selected_block, None, "a click leaves the keyboard selection alone");
assert!(app.outbox.copy.is_none(), "and copies nothing");
render_app(&mut app, &backend);
assert!(app.outbox.copy.is_none(), "still nothing on the next frame");
}

View File

@@ -0,0 +1,228 @@
//! Composer — the input box: its border, its growth, pastes and the pickers anchored to it.
use super::*;
/// Finds the composer's rounded top-left corner cell.
pub(super) fn composer_corner(buffer: &Buffer) -> (u16, u16) {
(0..buffer.area.height)
.flat_map(|y| (0..buffer.area.width).map(move |x| (x, y)))
.find(|&(x, y)| buffer[(x, y)].symbol() == "╭")
.expect("composer top-left corner")
}
/// The outline used to change color with a vim-style editor mode whenever the statusline was
/// hidden. It is the theme's base border color now, in every state.
#[test]
fn composer_border_keeps_the_base_color_in_every_state() {
let (width, height) = (80, 24);
let mut app = create_app();
app.statusline_state.hide();
let base = app.theme_styles.border_accent.fg.expect("base border color");
let buffer = render_app(&mut app, &test_backend(width, height));
assert_eq!(buffer[composer_corner(&buffer)].fg, base, "empty composer");
app.editor.insert_text("typing");
let buffer = render_app(&mut app, &test_backend(width, height));
assert_eq!(buffer[composer_corner(&buffer)].fg, base, "composer holding a draft");
app.selected_block = Some(0);
let buffer = render_app(&mut app, &test_backend(width, height));
assert_eq!(buffer[composer_corner(&buffer)].fg, base, "conversation block selected");
}
#[test]
fn multiline_input_grows_the_composer_and_preserves_line_breaks() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let mut app = create_app();
app.editor.insert_text("alpha\nbeta");
let buffer = render_app(&mut app, &backend);
assert!(row_text(&buffer, height - 4, width).contains("alpha"));
assert!(row_text(&buffer, height - 3, width).contains("beta"));
assert!(row_text(&buffer, height - 2, width).trim_start().starts_with('╰'));
}
#[test]
fn the_composer_grows_the_moment_the_draft_wraps() {
// The prompt box is framed, so its text area is two columns narrower than the terminal.
// Measuring the wrap at any wider value let the draft spill onto a second row while the frame
// was still one row tall — the first line scrolled out of sight and only the wrapped word
// showed until another keystroke arrived.
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let mut app = create_app();
// 73 a's + " bravo!": exactly 80 cells, so it fits a measurement that forgot the frame but not
// the 78 the box actually draws at.
let head = "a".repeat(73);
app.editor.insert_text(&format!("{head} bravo!"));
let buffer = render_app(&mut app, &backend);
assert!(row_text(&buffer, height - 4, width).contains(&head), "the first row keeps the draft");
assert!(row_text(&buffer, height - 3, width).contains("bravo!"), "the wrapped word is visible");
assert!(row_text(&buffer, height - 2, width).trim_start().starts_with('╰'), "box bottom");
}
#[test]
fn the_composer_grows_beside_the_dock_at_the_column_it_actually_wraps_at() {
// The sidebar case, which is where this was reported: the composer lives in the main column,
// so the wrap column comes off *that* width, not the terminal's.
let (width, height) = (160u16, 40u16);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::DockWide).unwrap();
app.update(Msg::TerminalResized { width, height });
let metrics = luxe_tui::workspace_layout::resolve_workspace_layout(width);
assert!(metrics.separator_width >= 1, "precondition: the dock sits beside the conversation");
// Sized so the trailing word overflows the real text area but would still fit the two extra
// columns the old measurement assumed — the exact window where the box used to lag.
// A column of air off the separator, then the frame
let text_width = usize::from(metrics.conversation_width) - 3;
let head = "a".repeat(text_width - " bravo!".len() + 2);
app.editor.insert_text(&format!("{head} bravo!"));
let buffer = render_app(&mut app, &backend);
let composer_top =
(0..height).rfind(|&y| row_text(&buffer, y, width).contains('╭')).expect("composer top");
assert!(
row_text(&buffer, composer_top + 1, width).contains(&head),
"the first row keeps the draft: {}",
buffer_to_string(&buffer)
);
assert!(
row_text(&buffer, composer_top + 2, width).contains("bravo!"),
"the wrapped word gets its own row: {}",
buffer_to_string(&buffer)
);
}
pub(super) fn assert_composer_paste_background(app: &mut App, marker: &str) {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let expected_bg = app.theme_styles.paste_indicator.bg.expect("paste background");
let buffer = render_app(app, &backend);
let row = height - 3;
// The composer is flush to the edge, so its inner text starts at x=1 (border at x=0)
let marker_start = 1 + "before ".len() as u16;
let marker_end = marker_start + marker.len() as u16 - 1;
let normal_bg = buffer[(1, row)].bg;
assert!(row_text(&buffer, row, width).contains(&format!("before {marker} after")));
assert_ne!(normal_bg, expected_bg);
for column in marker_start..=marker_end {
assert_eq!(buffer[(column, row)].bg, expected_bg, "column {column}");
}
assert_eq!(buffer[(marker_end + 2, row)].bg, normal_bg);
}
#[test]
fn compact_text_paste_has_a_distinct_background() {
let mut app = create_app();
app.editor.insert_text("before ");
app.editor.paste_text("one\ntwo\nthree");
app.editor.insert_text(" after");
assert_composer_paste_background(&mut app, "[Pasted 3 lines]");
}
#[cfg(feature = "clipboard-images")]
#[test]
fn compact_image_paste_uses_clean_wording_and_a_distinct_background() {
let mut app = create_app();
app.editor.insert_text("before ");
assert!(app.editor.attach_image(vec![255, 0, 0, 255], 1, 1));
app.editor.insert_text(" after");
assert_composer_paste_background(&mut app, "[Pasted Image]");
}
/// A slash command being typed shows in the composer.
#[test]
fn a_slash_command_being_typed_shows_in_the_composer() {
let backend = test_backend(80, 24);
let mut app = create_app();
app.editor.insert_text("/help");
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("/help"), "the command is missing: {rendered}");
}
#[test]
fn test_slash_picker_is_anchored_to_input() {
let (w, h) = (80, 24);
let backend = test_backend(w, h);
let mut app = create_app();
app.update(Msg::Key(key(KeyCode::Char('/'))));
app.update(Msg::Key(key(KeyCode::Char('h'))));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
let picker_title_row = (0..h)
.find(|&y| row_text(&buffer, y, w).contains(" Commands "))
.expect("slash picker title");
assert!(picker_title_row > 0, "picker must not be pinned to the top edge");
// The picker sits one row above the composer and shares its column
assert_eq!(buffer[(0, h - 5)].symbol(), "╰", "picker bottom-left must align with the composer");
assert!(content.contains("│/h"), "query should render without a prompt glyph: {content}");
}
#[test]
fn slash_picker_matches_composer_width_beside_the_dock() {
// Regression: the slash/@ pickers used to render at the full terminal width, so beside a
// side-by-side dock they spilled over the sidebar. They must inherit the composer's column.
let (w, h) = (160u16, 40u16);
let backend = test_backend(w, h);
let mut app = seeded_app("nord", FixtureScenario::DockWide).unwrap();
app.update(Msg::TerminalResized { width: w, height: h });
let metrics = luxe_tui::workspace_layout::resolve_workspace_layout(w);
assert!(metrics.dock_width > 0 && metrics.separator_width >= 1, "precondition: side-by-side");
app.update(Msg::Key(key(KeyCode::Char('/'))));
let buffer = render_app(&mut app, &backend);
// The composer box (rounded corners) defines the promptbox width.
let comp_row =
(0..h).find(|&y| row_text(&buffer, y, w).contains('╭')).expect("composer top border");
let comp_left = (0..w).find(|&x| buffer[(x, comp_row)].symbol() == "╭").unwrap();
let comp_right = (comp_left..w).find(|&x| buffer[(x, comp_row)].symbol() == "╮").unwrap();
// The picker box shares the composer's rounded corners and must line up with it, not the
// terminal edges.
let title_row = (0..h)
.find(|&y| row_text(&buffer, y, w).contains(" Commands "))
.expect("slash picker title");
let flyout_left = (0..w).find(|&x| buffer[(x, title_row)].symbol() == "╭").unwrap();
let flyout_right = (flyout_left..w).find(|&x| buffer[(x, title_row)].symbol() == "╮").unwrap();
assert_eq!(flyout_left, comp_left, "picker left edge must match the composer");
assert_eq!(flyout_right, comp_right, "picker right edge must match the composer");
assert!(
flyout_left >= metrics.dock_width + metrics.separator_width,
"picker must not cover the left sidebar (left={flyout_left}, dock={})",
metrics.dock_width
);
}
#[test]
fn test_mention_picker_is_anchored_to_input() {
let (w, h) = (80, 24);
let backend = test_backend(w, h);
let mut app = create_app();
app.update(Msg::Key(key(KeyCode::Char('@'))));
app.update(Msg::Key(key(KeyCode::Char('c'))));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
let picker_title_row = (0..h)
.find(|&y| row_text(&buffer, y, w).contains(" Files "))
.expect("mention picker title");
assert!(picker_title_row > 0, "picker must not be pinned to the top edge");
assert_eq!(buffer[(0, h - 5)].symbol(), "╰", "picker bottom-left must align with the composer");
assert!(content.contains("│@c"), "query should render without a prompt glyph: {content}");
}

View File

@@ -0,0 +1,632 @@
//! Dock — the rail's sections, its changes, counts and scrolling.
use super::*;
pub(super) fn empty_workspace(scope: &str) -> WorkspaceSnapshot {
WorkspaceSnapshot::empty(
WorkspaceScopeId::new(scope),
ProjectIdentity::non_git("/work/luxe".into(), "luxe", "~/work/luxe"),
)
}
/// The Changes dock section always surfaces the way into review when there are changes (not only
/// on overflow), and it says which key, so review stays discoverable without a keymap lookup.
#[test]
fn changes_section_surfaces_the_review_changes_affordance() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("changes-affordance");
snapshot.changes = WorkspaceChangesSummary {
files: vec![FileChangeSummary {
path: "src/lib.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(2),
deletions: Some(1),
binary: false,
}],
total_files: 1,
additions: Some(2),
deletions: Some(1),
truncated: false,
};
app.workspace = Some(snapshot);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("FILES"), "Files section renders: {content}");
assert!(
content.contains("ctrl+p preview · ctrl+g review"),
"the Changes section surfaces both ways in, even without overflow: {content}"
);
}
/// A folder row is a name and nothing else. The ± numbers belong to the file rows under it;
/// repeating a total on every folder doubled the digits in a 42-cell rail for no new information.
/// A file at the project root sits at the tree's top level, under no heading at all.
#[test]
fn the_tree_counts_on_files_and_never_on_folders() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let changed = |path: &str, additions, deletions| FileChangeSummary {
path: path.into(),
status: FileChangeStatus::Modified,
additions: Some(additions),
deletions: Some(deletions),
binary: false,
};
let mut snapshot = empty_workspace("changes-directories");
snapshot.changes = WorkspaceChangesSummary {
files: vec![
changed("README.md", 7, 2),
changed("src/lib.rs", 4, 1),
changed("src/app.rs", 9, 3),
],
total_files: 3,
additions: Some(20),
deletions: Some(6),
truncated: false,
};
app.workspace = Some(snapshot);
let buffer = render_app(&mut app, &backend);
let row = |needle: &str| {
(0..height)
.map(|y| row_text(&buffer, y, width))
.find(|text| text.contains(needle))
.unwrap_or_else(|| panic!("no dock row containing {needle:?}"))
};
let unnumbered = |text: &str| !text.contains('+') && !text.contains('\u{2212}');
let root = row("README.md");
assert!(root.contains("+7") && root.contains('M'), "a root file is a row like any: {root}");
let source = row(" src");
assert!(unnumbered(&source), "a folder carries no counts: {source}");
// The files still carry theirs — that is where the numbers were always readable.
let file = row("app.rs");
assert!(file.contains("+9") && file.contains('\u{2212}'), "file counts stay: {file}");
}
/// The hint names keys, and never a click — without mouse capture the terminal keeps the pointer,
/// and a row that offered a click would be advertising a gesture that does nothing.
#[test]
fn the_change_hints_name_keys_rather_than_promising_a_click() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app_with_config(Config { mouse: Some(false), ..Config::default() });
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("changes-hint-no-mouse");
snapshot.changes = WorkspaceChangesSummary {
files: vec![FileChangeSummary {
path: "src/lib.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(2),
deletions: Some(1),
binary: false,
}],
total_files: 1,
additions: Some(2),
deletions: Some(1),
truncated: false,
};
app.workspace = Some(snapshot);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("ctrl+p preview · ctrl+g review"), "the keys are named: {content}");
assert!(!content.contains("Click"), "and no click is offered: {content}");
}
/// The review's open comments stay on the wire and off the rail.
///
/// The count is `Draft + Open + NeedsVerification` — one state the reader has already acted on and
/// two that want them back — and the rail could reach none of them: it has no click target, and
/// `Ctrl+G` captures a *new* review rather than resuming the pinned one. A row that names
/// unfinished business with no route to it is worse than silence. `ReviewSummary` stays on the
/// snapshot, which is a published protocol.
#[test]
fn the_dock_draws_no_review_section_for_a_snapshot_that_carries_open_comments() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("dock-review-gate");
snapshot.review = Some(ReviewSummary {
id: "review-1".into(),
title: "Fix the stale reference".into(),
source: "working tree".into(),
unresolved_findings: 2,
completed_at_ms: 2,
});
assert_eq!(
snapshot.review.as_ref().map(|review| review.unresolved_findings),
Some(2),
"the snapshot still carries them"
);
app.workspace = Some(snapshot);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("PROJECT"), "the rail still renders: {content}");
assert!(!content.contains("REVIEW"), "no review heading: {content}");
assert!(!content.contains("open comment"), "no comment count: {content}");
assert!(!content.contains("Fix the stale reference"), "no review title: {content}");
}
/// Clicking the dock's "Review changes" affordance opens Guided Review (plan B3 mouse hook): the
/// render publishes a wrapping-aware region and the click dispatches `UiAction::ReviewOpen`.
#[test]
fn clicking_the_dock_review_changes_affordance_opens_review() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("dock-review-click");
snapshot.changes = WorkspaceChangesSummary {
files: vec![FileChangeSummary {
path: "src/lib.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(2),
deletions: Some(1),
binary: false,
}],
total_files: 1,
additions: Some(2),
deletions: Some(1),
truncated: false,
};
app.workspace = Some(snapshot);
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("ctrl+g review"))
.expect("the review affordance renders");
let hints = row_text(&buffer, row, width).trim_end().to_string();
assert!(hints.trim_start().starts_with("ctrl+p preview · ctrl+g review"), "{hints}");
// The row carries two affordances, so each has to answer for its own words.
let click_at = |app: &mut _, column| {
route_mouse(
app,
&MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column,
row,
modifiers: KeyModifiers::NONE,
},
)
};
let review_column =
u16::try_from(hints.find("ctrl+g").expect("the review hint is on the row") + 2)
.expect("a narrow rail");
match click_at(&mut app, review_column) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::DispatchUiAction(luxe_core::keymap::UiAction::ReviewOpen)),
"clicking the review words dispatches ReviewOpen"
),
other => panic!("expected a ReviewOpen dispatch from the click, got {other:?}"),
}
let peek_column =
u16::try_from(hints.find("ctrl+p").expect("the preview hint is on the row") + 2)
.expect("a narrow rail");
match click_at(&mut app, peek_column) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::DispatchUiAction(luxe_core::keymap::UiAction::ToggleChanges)),
"clicking the preview hint opens the preview, not the review"
),
other => panic!("expected a ToggleChanges dispatch from the click, got {other:?}"),
}
}
/// Clicking the dock's model row opens the model picker (plan B3): in the wide layout the
/// statusline hides and MODEL telemetry relocates into the dock footer as a clickable row.
#[test]
fn clicking_the_dock_model_row_opens_the_model_picker() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("dock-model-click"));
app.status.model = "test-model-xyz".into();
app.status.context_window = 128_000;
app.status.context_pct = 10.0;
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("test-model-xyz"))
.expect("the model row renders in the dock footer");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 5,
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => {
assert!(matches!(*message, Msg::OpenModelPicker), "the model row opens the picker")
}
other => panic!("expected an open-model-picker message, got {other:?}"),
}
}
/// The mouse wheel scrolls the informational dock when the cursor is over the panel (there is no
/// keyboard focus). A notch down advances the offset; the top clamps at zero.
#[test]
fn wheel_over_the_dock_scrolls_its_content() {
// A short viewport so the dock's (bounded) sections overflow the middle and a real max exists.
let (width, height) = (160, 12);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("dock-wheel-scroll");
// Plan is a fixed-size section (heading + counts + one row per todo), so eight of them reliably
// overflow a 12-row dock regardless of the height-scaled Changes cap.
let items: Vec<TodoSummaryItem> = (0..8)
.map(|n| TodoSummaryItem {
id: n.to_string(),
subject: format!("Task {n}"),
status: TodoSummaryStatus::Pending,
blocked_by: Vec::new(),
})
.collect();
snapshot.todos =
TodoSummary { pending: items.len(), total: items.len(), items, ..TodoSummary::default() };
app.workspace = Some(snapshot);
// Render once so the dock publishes its scroll region + max offset.
let _ = render_app(&mut app, &backend);
assert_eq!(app.dock.scroll, 0);
// A wheel over the dock rail (column 5) is inside the panel on a wide layout.
use crossterm::event::MouseEventKind;
let wheel = |kind| crossterm::event::MouseEvent {
kind,
column: 5,
row: 10,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &wheel(MouseEventKind::ScrollDown)) {
RouteAction::Msg(message) => app.update(*message),
other => {
panic!("expected a dock-scroll message from a wheel over the panel, got {other:?}")
}
}
assert!(app.dock.scroll > 0, "a wheel notch over the dock advances its scroll");
for _ in 0..5 {
if let RouteAction::Msg(message) = route_mouse(&mut app, &wheel(MouseEventKind::ScrollUp)) {
app.update(*message);
}
}
assert_eq!(app.dock.scroll, 0, "scrolling back up clamps at the top");
}
#[test]
fn dock_position_right_places_the_full_height_sidebar_on_the_right() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.dock.position = luxe_core::config::DockPosition::Right;
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("dock-right"));
let buffer = render_app(&mut app, &backend);
// The right rail hugs the right edge: panel starts at width - dock, its separator precedes it,
// and the heading sits flush at the 1-col content margin into the panel.
let dock_start = width - luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
let separator_x = dock_start - 1;
let context_x =
(0..width).find(|&x| buffer[(x, 0)].symbol() == "P").expect("dock heading should render");
assert_eq!(
context_x,
dock_start + 1 + DOCK_HEADING_LEAD,
"right dock heading badge opens on the 1-col content margin into the panel"
);
assert_eq!(
buffer[(separator_x, 0)].symbol(),
"│",
"separator on the top row precedes the right panel"
);
assert_eq!(
buffer[(separator_x, height - 1)].symbol(),
"│",
"right sidebar separator should reach the bottom row (full height)"
);
}
#[test]
fn hidden_statusline_relocates_model_telemetry_into_the_dock() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("telemetry"));
app.status.model = "gpt-4o".into();
app.status.context_window = 128_000;
app.status.context_pct = 42.0;
app.status.prompt_tokens = 1_200;
app.status.completion_tokens = 340;
app.status.session = luxe_core::usage::SessionUsage::single(
luxe_core::usage::UsageSource::Agent,
luxe_core::usage::UsageTotals {
calls: 3,
prompt_tokens: 12_400,
completion_tokens: 3_800,
cost_usd: 0.42,
..Default::default()
},
);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
// Wide + auto statusline => statusline hidden (the composer bottom-aligns), so telemetry
// migrates into the dock instead of riding the bar.
let composer_x = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH
+ luxe_tui::workspace_layout::CONTEXT_DOCK_SEPARATOR_WIDTH
+ 1;
assert_eq!(
buffer[(composer_x, height - 1)].symbol(),
"╰",
"statusline should be hidden on wide: {content}"
);
// Two sections, because they answer two questions: what is answering, and what this session
// has consumed — how full its window is, how many tokens went through it, what that cost.
assert!(content.contains("MODEL"), "missing the model section: {content}");
assert!(content.contains("gpt-4o"), "missing relocated model: {content}");
assert!(content.contains("thinking"), "the model's reasoning level rides with it: {content}");
assert!(content.contains("SESSION"), "missing the session section: {content}");
assert!(content.contains("42% of 128k"), "missing relocated context usage: {content}");
assert!(content.contains("$0.42"), "missing relocated session cost: {content}");
assert!(!content.contains("CONTEXT"), "the meter reads under SESSION now: {content}");
assert!(!content.contains("lsp "), "the constant lsp row is gone: {content}");
}
#[test]
fn forced_statusline_beside_the_sidebar_keeps_the_dock_model_section() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("beside"));
app.status.model = "gpt-4o".into();
app.statusline_state.show();
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
// The sidebar's MODEL footer is decoupled from the statusline: a forced-on statusline sits
// beside the full-height sidebar and BOTH carry telemetry (the sidebar keeps its own footer
// rather than emptying it). `auto` still yields exactly one copy by hiding the bar.
assert!(
row_text(&buffer, height - 1, width).contains("gpt-4o"),
"forced statusline should show the model on its bottom row: {content}"
);
assert!(content.contains("PROJECT"), "sidebar should still render: {content}");
assert!(
content.contains("MODEL"),
"sidebar should keep its MODEL section even with the statusline shown: {content}"
);
// The sidebar remains full-height even with the statusline in the main column.
let sep_x = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
assert_eq!(
buffer[(sep_x, height - 1)].symbol(),
"│",
"sidebar should still reach the bottom row"
);
}
/// Diagnostics stay on the wire and off the rail.
///
/// The snapshot still carries them — `Event::WorkspaceUpdated` is a published protocol and an RPC
/// front-end may want them — but the dock draws no section for them. The counts only cover files
/// the agent edited this session with a warm language server attached, so a rail read as fact
/// cannot show them: `✗ 0` there reads as "the project is clean" and means "nothing found in what I
/// touched". The agent gets every diagnostic injected after the edit that caused it, which is where
/// it can still be acted on.
#[test]
fn the_dock_draws_no_diagnostics_section_for_a_snapshot_that_carries_them() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("diagnostics");
snapshot.diagnostics = DiagnosticsSummary {
errors: 3,
warnings: 2,
infos: 0,
hints: 0,
files: vec![
FileDiagnostics {
path: "src/main.rs".into(),
errors: 3,
warnings: 1,
infos: 0,
hints: 0,
},
FileDiagnostics {
path: "src/lib.rs".into(),
errors: 0,
warnings: 1,
infos: 0,
hints: 0,
},
],
total_files: 5,
truncated: true,
};
assert!(!snapshot.diagnostics.is_empty(), "the snapshot still carries them");
app.workspace = Some(snapshot);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("PROJECT"), "the rail still renders: {content}");
assert!(!content.contains("DIAGNOSTICS"), "no diagnostics heading: {content}");
assert!(!content.contains("src/main.rs"), "no per-file diagnostic row: {content}");
assert!(!content.contains("3✗"), "no per-file counts: {content}");
}
#[test]
fn idle_dock_omits_the_now_section() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
// Empty snapshot: no attention, no telemetry, idle turn.
app.workspace = Some(empty_workspace("idle"));
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("PROJECT"), "identity should still render: {content}");
// NOW is attention-only now: an idle dock shows no permanent "● Idle" row.
assert!(!content.contains("NOW"), "idle dock must omit the NOW heading: {content}");
assert!(!content.contains("● Idle"), "idle dock must omit the '● Idle' row: {content}");
}
#[test]
fn dock_footer_bottom_anchors_model_telemetry() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(empty_workspace("footer-telemetry"));
app.status.model = "gpt-4o".into();
app.status.context_window = 128_000;
app.status.context_pct = 42.0;
app.status.cost_usd = Some(0.42);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("MODEL"), "footer should carry telemetry: {content}");
let project_row = (0..height)
.find(|&row| row_text(&buffer, row, width).contains("PROJECT"))
.expect("PROJECT heading row");
let model_row = (0..height)
.find(|&row| row_text(&buffer, row, width).contains("MODEL"))
.expect("MODEL heading row");
// Identity stays at the top; telemetry sinks to the bottom near the composer.
assert!(model_row > project_row, "telemetry should sit below identity: {content}");
// Heading, model, thinking and mode, then SESSION's heading, context and cost
assert!(
model_row >= height - 7,
"telemetry should be bottom-anchored (row {model_row} of {height}): {content}"
);
}
/// The CHANGES section colors each file's counts like its summary line and the Guided Review file
/// rows: additions in the success color, deletions in the error color (not a flat muted run).
#[test]
fn dock_changes_group_rows_color_the_add_remove_counts() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("changes-color");
snapshot.changes = WorkspaceChangesSummary {
files: vec![FileChangeSummary {
path: "src/lib.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(12),
deletions: Some(3),
binary: false,
}],
total_files: 1,
additions: Some(12),
deletions: Some(3),
truncated: false,
};
app.workspace = Some(snapshot);
let buffer = render_app(&mut app, &backend);
// The file row carries the counts; the heading over a single file leaves them to it.
let row = (0..height)
.find(|&y| {
let text = row_text(&buffer, y, width);
text.contains("lib.rs") && text.contains("+12")
})
.expect("the changed file row renders");
let plus_col = (0..width).find(|&x| buffer[(x, row)].symbol() == "+").expect("additions count");
let minus_col =
(plus_col + 1..width).find(|&x| buffer[(x, row)].symbol() == "−").expect("deletions count");
assert_eq!(
buffer[(plus_col, row)].fg,
app.theme_styles.success.fg.expect("success fg"),
"additions should use the success color"
);
assert_eq!(
buffer[(minus_col, row)].fg,
app.theme_styles.error.fg.expect("error fg"),
"deletions should use the error color"
);
}
/// The dock's changed files are a list you pick from, so the one under the pointer is cut from the
/// slab that means *chosen* everywhere else — tapering into the rail's own fill, not the color
/// behind it, and without moving the name off the column it shares with every other row.
#[test]
fn a_hovered_dock_file_row_is_cut_into_a_slab_on_the_rails_own_fill() {
luxe_tui::glyphs::set_tier(luxe_tui::glyphs::GlyphTier::Nerd);
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
// Every bundled theme paints the rail the same color as the app background, which would let a
// cap cut against the wrong canvas pass unnoticed. A theme is free to raise it, so this one
// does.
const RAIL: ratatui::style::Color = ratatui::style::Color::Rgb(0x21, 0x1e, 0x1a);
app.theme_styles.tool_bg = ratatui::style::Style::new().bg(RAIL);
let mut snapshot = empty_workspace("changes-hover");
let file = |path: &str| FileChangeSummary {
path: path.into(),
status: FileChangeStatus::Modified,
additions: Some(4),
deletions: Some(1),
binary: false,
};
snapshot.changes = WorkspaceChangesSummary {
files: vec![file("src/lib.rs"), file("src/main.rs")],
total_files: 2,
additions: Some(8),
deletions: Some(2),
truncated: false,
};
app.workspace = Some(snapshot);
let plain = render_app(&mut app, &backend);
app.pointer.hover = Some(luxe_tui::mouse::MouseTarget::DockFile("src/lib.rs".into()));
let hovered = render_app(&mut app, &backend);
let column = |buffer: &ratatui::buffer::Buffer, needle: &str| -> (u16, u16) {
(0..height)
.find_map(|y| {
let text = row_text(buffer, y, width);
text.find(needle)
.map(|byte| (unicode_width::UnicodeWidthStr::width(&text[..byte]) as u16, y))
})
.unwrap_or_else(|| panic!("the {needle} row renders"))
};
let (name_x, row) = column(&hovered, "lib.rs");
assert_eq!(
(name_x, row),
column(&plain, "lib.rs"),
"the indent a file row already spent is the slab's own frame, so nothing moves"
);
let line = row_text(&hovered, row, width);
let cap = luxe_tui::widgets::Cap::Open.glyph();
let cut = line.find(cap).expect("the hovered row opens on a cut");
let cut_x = unicode_width::UnicodeWidthStr::width(&line[..cut]) as u16;
assert!(cut_x < name_x, "and the cut opens before the name: {line:?}");
// A cap is the slab's color over the canvas *behind* it. On a raised rail that canvas is the
// rail's own fill; against the app background it would leave a notch at the diagonal.
assert_eq!(
hovered[(cut_x, row)].bg,
RAIL,
"the cut tapers into the rail, not into the color behind it"
);
assert_eq!(
hovered[(cut_x, row)].fg,
app.theme_styles.selected_bg.bg.expect("the theme defines a selection"),
);
// The row that is not hovered keeps the rail's fill and no cut at all.
let (_, other) = column(&hovered, "main.rs");
assert!(!row_text(&hovered, other, width).contains(cap), "only one row is chosen");
}

View File

@@ -0,0 +1,295 @@
//! Elsewhere — work done outside the project, listed in the rail.
use super::*;
/// A session that changed one file in a checkout of its own, somewhere else.
pub(super) fn external_workspace() -> luxe_core::WorkspaceSnapshot {
let mut snapshot = empty_workspace("elsewhere");
snapshot.external = luxe_core::ExternalChangesSummary {
roots: vec![luxe_core::ExternalRootSummary {
root: "/work/sdk".into(),
display_path: "~/work/sdk".into(),
git_branch: Some("main".into()),
git: true,
files: vec![FileChangeSummary {
path: "src/client.ts".into(),
status: FileChangeStatus::Modified,
additions: Some(18),
deletions: Some(3),
binary: false,
}],
total_files: 1,
truncated: false,
}],
total_files: 1,
additions: Some(18),
deletions: Some(3),
truncated: false,
};
snapshot
}
/// Work done outside the project gets its own section, and deliberately no way into review.
///
/// A review is captured from the project's Git worktree and its chapters end in commits to it, so
/// a file that lives somewhere else can never be one of its items. Offering the affordance over
/// these rows would advertise something the review cannot do — a *peek* is a promise the section
/// can keep, and that is the one its rows carry.
#[test]
fn dock_lists_external_work_without_offering_to_review_it() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(external_workspace());
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("ELSEWHERE"), "the section is drawn: {content}");
assert!(content.contains("1 file outside this project"), "singular, and it says where");
assert!(content.contains("~/work/sdk"), "the place is named");
assert!(content.contains("main"), "and its branch, since Git reports the whole tree there");
assert!(content.contains("client.ts"), "with the file under it");
assert!(
!content.contains("to review"),
"no review affordance: a project review cannot contain these files\n{content}"
);
}
/// A file listed elsewhere opens the same way a file listed in CHANGES does.
///
/// The rows are drawn in the project's own hand — same marker, same ±, same indent — so a reader
/// who has learned that a file name opens its change has already been told these do too. They
/// carry the absolute path, which is what tells every surface downstream that the project's Git
/// cannot answer for them.
#[test]
fn clicking_an_elsewhere_row_peeks_that_file() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(external_workspace());
let buffer = render_app(&mut app, &backend);
let row = dock_row_containing(&buffer, "client.ts", height);
match left_click(&mut app, 5, row) {
RouteAction::Msg(message) => assert!(
matches!(&*message, Msg::OpenChanges(path) if path == "/work/sdk/src/client.ts"),
"expected the file's absolute path, got {message:?}"
),
other => panic!("expected a peek to open from the click, got {other:?}"),
}
}
/// Looking at a file elsewhere is the only thing that can happen to it, so it is what makes the
/// section recede: a place with nothing left unread folds to its heading.
///
/// Driven through the pane the way a reader would, because the recording is the peek's own doing:
/// nothing else marks these files, and a look that did not mark one would leave the section
/// growing for the whole session no matter what the reader did about it.
#[test]
fn an_elsewhere_place_folds_once_everything_under_it_has_been_seen() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(external_workspace());
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("client.ts"), "unread work is listed: {content}");
let path = "/work/sdk/src/client.ts";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let reading = buffer_to_string(&render_app(&mut app, &backend));
assert!(
reading.contains("client.ts"),
"the row stays while the pane is showing it — a fold here would take it out from under \
the click that opened it: {reading}"
);
app.update(Msg::CloseChanges);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(!content.contains("client.ts"), "a place with nothing unread folds away: {content}");
assert!(content.contains("~/work/sdk"), "but never silently: {content}");
assert!(content.contains("1 file"), "and it says how much is under it: {content}");
// The heading is the control, so a folded place can always be opened again.
let row = dock_row_containing(&buffer, "~/work/sdk", height);
match left_click(&mut app, 5, row) {
RouteAction::Msg(message) => {
assert!(
matches!(&*message, Msg::ToggleExternalPlace(place) if place == "/work/sdk"),
"expected the place to toggle, got {message:?}"
);
app.update(*message);
}
other => panic!("expected a fold toggle from the click, got {other:?}"),
}
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("client.ts"), "unfolded by hand: {content}");
}
/// Files elsewhere are grouped under folder headings the way the project's own are, so a folder
/// reads the same wherever the rail draws one.
///
/// A file at a place's own root gets no heading: the place above it already is its directory, and
/// a `/ (root)` row under it would say the same thing twice.
#[test]
fn elsewhere_groups_its_files_under_folder_headings() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(places_workspace("elsewhere-folders", 1, 2));
let buffer = render_app(&mut app, &backend);
let rail = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
// Where a row's name starts, after its guides, chevron and icon: what the eye reads as nesting.
let indent = |needle: &str| {
let row = row_text(&buffer, dock_row_containing(&buffer, needle, height), rail);
row[..row.find(needle).expect("the row has it")].chars().count()
};
// Place, then folder, then the files under it — each a step further in.
let (place, folder, file) = (indent("~/work/place0"), indent("nested"), indent("file00.ts"));
assert!(place < folder && folder < file, "place {place}, folder {folder}, file {file}");
// The file sitting at the place's own root skips the folder level entirely.
assert_eq!(indent("root.ts"), folder, "a root file sits where a folder heading would");
let content = buffer_to_string(&buffer);
assert!(!content.contains("(root)"), "and needs no heading of its own: {content}");
}
/// ELSEWHERE is a viewport onto every place, not the first three of them: the caps that used to
/// count the rest are gone, and the lane beside it reaches them instead.
#[test]
fn every_place_elsewhere_is_reachable_by_scrolling() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(places_workspace("elsewhere-scroll", 6, 2));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("~/work/place0"), "the first place leads: {content}");
assert!(!content.contains("~/work/place5"), "and the last is below the fold");
assert!(!content.contains("more place"), "counted places are gone: {content}");
let lane = dock_scroll_lane(&buffer, "~/work/place0", height);
assert_eq!(lane.first().copied(), Some(THUMB), "the thumb is at the top: {lane:?}");
// The wheel over the section moves the section, and reaches the last place.
let row = dock_row_containing(&buffer, "~/work/place0", height);
assert!(
matches!(wheel_down(&mut app, 5, row), RouteAction::Msg(message)
if matches!(*message, Msg::ScrollDockList { list: DockList::Elsewhere, up: false })),
"the wheel over ELSEWHERE moves ELSEWHERE"
);
// One notch opens the window inside the first place — which still has to say which place, and
// which folder, its rows are under.
app.update(Msg::ScrollDockList { list: DockList::Elsewhere, up: false });
let buffer = render_app(&mut app, &backend);
let rail = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
let headline = dock_row_containing(&buffer, "outside this project", height);
let under = |offset: u16| row_text(&buffer, headline + offset, rail);
assert!(under(1).contains("~/work/place0"), "the place is repeated: {:?}", under(1));
assert!(under(2).contains("nested"), "and the folder inside it: {:?}", under(2));
assert!(under(3).contains("file0"), "before the rows the window actually opened on");
let mut reached = false;
for _ in 0..40 {
app.update(Msg::ScrollDockList { list: DockList::Elsewhere, up: false });
if buffer_to_string(&render_app(&mut app, &backend)).contains("~/work/place5") {
reached = true;
break;
}
}
assert!(reached, "every place is reachable by scrolling");
}
/// `count` places outside the project, each with `files` files under a folder plus one at its root.
pub(super) fn places_workspace(scope: &str, count: usize, files: usize) -> WorkspaceSnapshot {
let mut snapshot = empty_workspace(scope);
let change = |path: String| FileChangeSummary {
path: path.into(),
status: FileChangeStatus::Modified,
additions: Some(4),
deletions: Some(1),
binary: false,
};
let roots: Vec<luxe_core::ExternalRootSummary> = (0..count)
.map(|place| {
let mut entries: Vec<FileChangeSummary> =
(0..files).map(|index| change(format!("nested/file{index:02}.ts"))).collect();
entries.push(change("root.ts".to_string()));
luxe_core::ExternalRootSummary {
root: format!("/work/place{place}").into(),
display_path: format!("~/work/place{place}"),
git_branch: None,
git: false,
total_files: entries.len(),
files: entries,
truncated: false,
}
})
.collect();
snapshot.external = luxe_core::ExternalChangesSummary {
total_files: roots.iter().map(|root| root.total_files).sum(),
additions: Some(4),
deletions: Some(1),
roots,
truncated: false,
};
snapshot
}
/// A file touched again since it was looked at is new work, whatever was read before — the same
/// rule the project's own reviewed markers follow, and what keeps a fold from hiding fresh edits.
#[test]
fn work_done_elsewhere_since_the_last_look_comes_back_unread() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(external_workspace());
let path = "/work/sdk/src/client.ts";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
app.update(Msg::CloseChanges);
assert!(!buffer_to_string(&render_app(&mut app, &backend)).contains("client.ts"), "seen");
if let Some(workspace) = app.workspace.as_mut() {
workspace.external.roots[0].files[0].additions = Some(40);
}
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("client.ts"), "touched again since, so unread again: {content}");
}
/// The project's own Changes section keeps its way into review — the assertion above only means
/// something if the affordance is present when it should be.
#[test]
fn dock_still_offers_review_for_the_projects_own_changes() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("changes");
snapshot.changes = WorkspaceChangesSummary {
files: vec![FileChangeSummary {
path: "src/lib.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(1),
deletions: Some(0),
binary: false,
}],
total_files: 1,
additions: Some(1),
deletions: Some(0),
truncated: false,
};
app.workspace = Some(snapshot);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("ctrl+g review"), "in-project changes lead to a review: {content}");
}

View File

@@ -0,0 +1,297 @@
//! Files — the project tree, the file view and the start screen's flyouts.
use super::*;
/// The next action the app sends that is not the tree asking for a folder.
pub(super) fn next_action_but_listings(
rx: &mut tokio::sync::mpsc::Receiver<luxe_core::engine::Action>,
) -> luxe_core::engine::Action {
loop {
match rx.try_recv().expect("an action was sent") {
luxe_core::engine::Action::ListDirectory { .. } => continue,
action => return action,
}
}
}
/// Opens `path` from the tree as an unchanged file, and lands `text` as what the engine read.
pub(super) fn open_file_view(
app: &mut App,
rx: &mut tokio::sync::mpsc::Receiver<luxe_core::engine::Action>,
path: &str,
text: &str,
) {
app.update(Msg::OpenProjectFile(path.to_string()));
let request_id = match next_action_but_listings(rx) {
luxe_core::engine::Action::ReadProjectFile { request_id, path: asked } => {
assert_eq!(asked, path, "it reads the file it is showing");
request_id
}
other => panic!("an unchanged file is read, not diffed: {other:?}"),
};
app.update(Msg::Engine(luxe_core::event::Event::ProjectFileRead {
request_id,
file: Box::new(luxe_core::project_files::ProjectFile {
path: path.to_string(),
text: text.to_string(),
bytes: text.len() as u64,
truncated: false,
binary: false,
}),
}));
}
/// A workspace arriving is what asks for the project root, and a listing that lands is drawn
/// beside the changes — the tree is the project, not only the part of it that changed.
#[test]
fn the_tree_lists_the_project_beside_its_changes() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.update(Msg::Engine(luxe_core::event::Event::WorkspaceUpdated(Box::new(
changed_workspace("tree-listing", 1),
))));
let request_id = match rx.try_recv().expect("the root is asked for") {
luxe_core::engine::Action::ListDirectory { request_id, path, .. } => {
assert_eq!(path, "", "the project root first");
request_id
}
other => panic!("expected a listing request, got {other:?}"),
};
let entry = |name: &str, kind| luxe_core::project_files::DirectoryEntry {
name: name.into(),
kind,
ignored: false,
};
use luxe_core::project_files::EntryKind;
app.update(Msg::Engine(luxe_core::event::Event::DirectoryListed {
request_id,
listing: luxe_core::project_files::DirectoryListing {
path: String::new(),
entries: vec![
entry("docs", EntryKind::Directory),
entry("src", EntryKind::Directory),
entry("Cargo.toml", EntryKind::File),
],
omitted: 0,
},
}));
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("Cargo.toml"), "an unchanged file is in the tree: {content}");
assert!(content.contains("docs"), "and a folder nothing changed in: {content}");
assert!(content.contains("file00.rs"), "and the change, revealed: {content}");
}
/// A file that did not change opens whole, numbered and highlighted, with no Diff to switch to.
#[test]
fn an_unchanged_file_opens_whole_in_the_file_view() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("file-view", 1));
open_file_view(&mut app, &mut rx, "README.md", "# Title\nsecond line\n");
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("README.md"), "the header names it: {content}");
let second = row_containing(&buffer, "second line", width, height);
assert!(row_text(&buffer, second, width).contains(" 2 "), "lines are numbered: {content}");
assert!(!content.contains("DIFF"), "nothing changed, so there is no diff to show: {content}");
assert!(content.contains("esc close"), "and it says how to leave: {content}");
}
/// Dragging down the line numbers picks lines, and Ask turns the pick into a mention in the
/// composer — a pointer to the lines, not a paste of them. (A drag over the code selects text.)
#[test]
fn picked_lines_become_a_mention_in_the_composer() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("file-pick", 1));
open_file_view(&mut app, &mut rx, "README.md", "one\ntwo\nthree\nfour\n");
let buffer = render_app(&mut app, &backend);
let from = row_containing(&buffer, "two", width, height);
let to = row_containing(&buffer, "three", width, height);
// The number, the keyboard's mark, the change bar and a space come before the code
let gutter = column_of(&row_text(&buffer, from, width), "two") - 4;
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
for (kind, row) in [
(MouseEventKind::Down(MouseButton::Left), from),
(MouseEventKind::Drag(MouseButton::Left), to),
(MouseEventKind::Up(MouseButton::Left), to),
] {
let event = MouseEvent { kind, column: gutter, row, modifiers: KeyModifiers::NONE };
let action = route_mouse(&mut app, &event);
apply(&mut app, action);
}
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("ask about lines 2–3"), "the pick offers the question: {content}");
app.update(Msg::PeekSelectionAction(luxe_tui::mouse::PeekSelectionAction::Ask));
assert_eq!(app.editor.current_input().trim(), "@[file:README.md:2-3]");
}
/// A right-click on a file in the tree offers what can be done with it, each with its key.
#[test]
fn a_right_click_on_a_file_opens_its_menu() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("file-menu", 2));
let buffer = render_app(&mut app, &backend);
let row = dock_row_containing(&buffer, "file00.rs", height);
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let event = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Right),
column: 12,
row,
modifiers: KeyModifiers::NONE,
};
route_mouse(&mut app, &event);
let menu = app.overlays.context_menu.as_ref().expect("a menu opened");
let labels: Vec<&str> = menu.items.iter().map(|item| item.label.as_str()).collect();
assert!(labels.contains(&"Show the diff"), "a changed file offers its diff: {labels:?}");
assert!(labels.contains(&"Copy path"), "{labels:?}");
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("Open in editor"), "and it is drawn: {content}");
// A click anywhere else puts it away
left_click(&mut app, 120, 2);
assert!(app.overlays.context_menu.is_none());
}
/// `Ctrl+T` puts the keyboard in the tree, the tree's own keys move through it, and `Enter` shows
/// the file the cursor is on.
#[test]
fn the_keyboard_walks_the_tree() {
let (width, height) = (160, 40);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.workspace = Some(changed_workspace("file-keys", 2));
let key = |code| Msg::Key(KeyEvent::new(code, KeyModifiers::NONE));
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL)));
assert!(app.files.focused, "the keyboard is in the tree");
assert_eq!(app.files.cursor.as_deref(), Some("src"), "on its first row");
for _ in 0..2 {
app.update(key(KeyCode::Char('j')));
}
assert_eq!(app.files.cursor.as_deref(), Some("src/module00/file00.rs"));
app.update(key(KeyCode::Enter));
match next_action_but_listings(&mut rx) {
luxe_core::engine::Action::LoadFileDiff { path, .. } => {
assert_eq!(path, "src/module00/file00.rs", "a changed file opens on its diff")
}
other => panic!("expected the diff to load, got {other:?}"),
}
assert_eq!(app.editor.current_input(), "", "the keys moved the tree, not the draft");
app.update(key(KeyCode::Esc));
assert!(!app.files.focused, "Esc gives the keyboard back");
}
/// The peek's FILE / DIFF switch: both faces in capitals, both slabs, neither moving when the
/// view flips, and the hidden face — the whole of it — is what a click reaches.
#[test]
fn the_view_switch_names_both_faces_and_the_hidden_one_takes_the_click() {
let (width, height) = (200, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("view-switch", 2));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
let header = row_containing(&buffer, "DIFF", width, height);
let text = row_text(&buffer, header, width);
let (file_at, diff_at) = (text.find("FILE"), text.find("DIFF"));
assert!(file_at.is_some(), "the hidden face is named in capitals too: {text}");
assert!(!text.contains(" file "), "and never as a lowercase word: {text}");
let file_x = text[..file_at.unwrap()].chars().count() as u16;
let lit = buffer[(file_x + 1, header)].bg;
assert_ne!(lit, buffer[(width - 1, header)].bg, "the hidden face sits on a slab of its own");
// Every cell of the hidden badge is the click target, and none of the showing one is
for x in file_x.saturating_sub(2)..file_x + 4 + 4 {
assert_eq!(
app.hit.borrow().at(x, header),
Some(&luxe_tui::mouse::MouseTarget::ChangesFooter(
luxe_tui::mouse::ChangesFooterAction::ToggleView
)),
"column {x} of the hidden face toggles the view"
);
}
let diff_x = text[..diff_at.unwrap()].chars().count() as u16;
assert_eq!(app.hit.borrow().at(diff_x + 1, header), None, "the showing face is not a button");
app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::ChangesToggleView));
let buffer = render_app(&mut app, &backend);
let flipped = row_text(&buffer, header, width);
assert_eq!(flipped.find("FILE"), file_at, "FILE holds its column when the view flips");
assert_eq!(flipped.find("DIFF"), diff_at, "and so does DIFF");
}
/// Drives a key through the start screen the way the event loop does.
pub(super) fn press_on_dashboard(app: &mut App, code: KeyCode) {
match route_key(app, &key(code)) {
RouteAction::Msg(message) => app.update(*message),
RouteAction::Dashboard(outcome) => app.handle_dashboard_outcome(outcome),
RouteAction::None => {}
other => panic!("{code:?} routed to {other:?}"),
}
}
/// The start screen's prompt is the session's composer, so `/` and `@` open its flyouts — under
/// the prompt rather than over it, since here the room is below — and the launcher's list folds
/// away while one is open.
#[test]
fn the_start_screens_prompt_opens_the_composers_flyouts_below_it() {
let (width, height) = (140, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::Dashboard).expect("the fixture");
app.update(Msg::TerminalResized { width, height });
press_on_dashboard(&mut app, KeyCode::Char('@'));
assert!(app.overlays.mention.is_some(), "@ opens the mention flyout");
let buffer = render_app(&mut app, &backend);
let prompt = row_containing(&buffer, "build", width, height);
let mention = row_containing(&buffer, "Mention", width, height);
assert!(mention > prompt, "it hangs below the prompt: {mention} vs {prompt}");
let screen = buffer_to_string(&buffer);
assert!(!screen.contains("New session"), "and the list has made way for it: {screen}");
press_on_dashboard(&mut app, KeyCode::Esc);
assert!(app.overlays.mention.is_none(), "esc puts it away");
assert_eq!(app.current_view, ViewMode::Dashboard, "and nothing else");
}
/// A command chosen from the slash flyout runs the way the launcher runs one: the theme picker
/// opens over the start screen rather than in a session that is not there.
#[test]
fn a_command_chosen_from_the_slash_flyout_runs_on_the_start_screen() {
let (width, height) = (140, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::Dashboard).expect("the fixture");
app.update(Msg::TerminalResized { width, height });
for character in "/theme".chars() {
press_on_dashboard(&mut app, KeyCode::Char(character));
}
assert!(app.overlays.slash_flyout.is_some(), "/ opens the command flyout");
let buffer = render_app(&mut app, &backend);
let prompt = row_containing(&buffer, "build", width, height);
let commands = row_containing(&buffer, "Commands", width, height);
assert!(commands > prompt, "below the prompt: {commands} vs {prompt}");
press_on_dashboard(&mut app, KeyCode::Enter);
assert!(app.overlays.theme_picker.is_some(), "the theme picker opened");
assert_eq!(app.current_view, ViewMode::Dashboard, "over the start screen");
assert!(app.editor.current_input().is_empty(), "and the command left the prompt");
}

View File

@@ -0,0 +1,441 @@
//! Hints — what an idle turn offers, the first-steps line and the review footer.
use super::*;
/// The turn-end invitation: quiet, honest, and only once a review has actually happened.
#[test]
fn an_idle_turn_invites_a_review_of_what_is_unreviewed() {
let (width, height) = (120, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("invitation");
snapshot.changes = WorkspaceChangesSummary {
files: vec![
FileChangeSummary {
path: "src/lib.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(12),
deletions: Some(3),
binary: false,
},
FileChangeSummary {
path: "src/new.rs".into(),
status: FileChangeStatus::Added,
additions: Some(40),
deletions: Some(0),
binary: false,
},
],
total_files: 2,
additions: Some(52),
deletions: Some(3),
truncated: false,
};
app.workspace = Some(snapshot);
// No prior review: "everything is unreviewed" is true and useless, so nothing is said.
let first = buffer_to_string(&render_app(&mut app, &backend));
assert!(!first.contains("since your last review"), "nothing to compare against: {first}");
// After a review that covered one of the two files, the other is the increment.
app.review.seen = Some(luxe_core::guided_review::SeenReview {
revision_id: None,
at_ms: 1,
item_ids: vec!["hunk:seen".into()],
files: [("src/lib.rs".to_string(), (12, 3))].into_iter().collect(),
});
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
content.contains("1 file changed since your last review"),
"the increment is named: {content}"
);
assert!(content.contains("ctrl+g to review"), "and it says how: {content}");
assert!(
!content.contains("for commands"),
"the invitation is about something that happened, so it has the row: {content}"
);
}
/// The row above the composer, as text, and where the composer's frame starts.
pub(super) fn row_above_composer(buffer: &Buffer, width: u16, height: u16) -> (String, u16) {
let composer = (0..height)
.rev()
.find(|&y| {
let row = row_text(buffer, y, width);
row.contains('╭') && row.contains('╮')
})
.expect("the composer's frame");
(row_text(buffer, composer - 1, width), composer)
}
/// A conversation that has not started says where the composer's doors are, in the row above it,
/// and says nothing once there is a message. Nothing else on screen names `/`, `Ctrl+K` or `@`.
#[test]
fn a_fresh_conversation_names_the_composers_doors_until_its_first_message() {
let (width, height) = (190, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let (row, _) = row_above_composer(&render_app(&mut app, &backend), width, height);
assert!(
row.contains("shift+tab for plan mode · / or ctrl+k for commands · @ to reference files, skills, and more · /help for keys"),
"{row:?}"
);
let buffer = render_app(&mut app, &backend);
let (row, composer) = row_above_composer(&buffer, width, height);
let styled = |needle: &str| {
let x = row[..row.find(needle).expect(needle)].chars().count() as u16;
buffer[(x, composer - 1)].fg
};
assert_eq!(Some(styled("ctrl+k")), app.theme_styles.accent.fg, "a key reads as a key");
assert_eq!(Some(styled("shift+tab")), app.theme_styles.accent.fg, "the mode key too");
assert_eq!(Some(styled("for commands")), app.theme_styles.muted.fg, "the words stay quiet");
// A notice — the line `--issue` leaves — does not start a conversation
app.push_convo(ConvoBlock::System("Issue #12 — will be sent with your first message.".into()));
let (row, _) = row_above_composer(&render_app(&mut app, &backend), width, height);
assert!(row.contains("for commands"), "a notice is not a conversation: {row:?}");
app.push_convo(ConvoBlock::User {
text: "hello".into(),
attached: Vec::new(),
chips: Vec::new(),
});
let (row, _) = row_above_composer(&render_app(&mut app, &backend), width, height);
assert!(!row.contains("for commands"), "gone once the conversation starts: {row:?}");
// Nor does a conversation with a reply in it count as fresh, whoever wrote the rest
let mut replied = create_app();
replied.update(Msg::TerminalResized { width, height });
replied.push_convo(ConvoBlock::Assistant("Here is the plan.".into()));
let (row, _) = row_above_composer(&render_app(&mut replied, &backend), width, height);
assert!(!row.contains("for commands"), "{row:?}");
}
/// The mode hint names the mode the key would switch to, and the key that is bound to do it.
#[test]
fn the_first_steps_hint_names_the_mode_shift_tab_reaches() {
let (width, height) = (190, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.status.mode = "plan".into();
let (row, _) = row_above_composer(&render_app(&mut app, &backend), width, height);
assert!(
row.contains(" shift+tab for build mode · / or"),
"planning, it offers build: {row:?}"
);
let keymap = KeyMap::defaults().with_overrides(std::collections::HashMap::from([(
"tui.app.cycle_mode".to_string(),
vec!["not a chord".to_string()],
)]));
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(8);
let mut unbound = App::new(tx, keymap, Config::default());
unbound.update(Msg::TerminalResized { width, height });
let (row, _) = row_above_composer(&render_app(&mut unbound, &backend), width, height);
assert!(!row.contains("mode") && row.contains("/ or ctrl+k"), "unbound, left out: {row:?}");
}
/// The palette's key is the one bound now; with none bound it is left out rather than invented.
#[test]
fn the_first_steps_hint_names_the_palette_key_you_bound() {
let (width, height) = (140, 30);
let backend = test_backend(width, height);
let bound = |chords: &[&str]| {
let keymap = KeyMap::defaults().with_overrides(std::collections::HashMap::from([(
"tui.app.open_palette".to_string(),
chords.iter().map(|chord| chord.to_string()).collect(),
)]));
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(8);
let mut app = App::new(tx, keymap, Config::default());
app.update(Msg::TerminalResized { width, height });
row_above_composer(&render_app(&mut app, &backend), width, height).0
};
assert!(bound(&["alt+p"]).contains("/ or alt+p for commands"));
// Every chord unparseable leaves the action unbound
let unbound = bound(&["not a chord"]);
assert!(unbound.contains(" / for commands · @"), "{unbound:?}");
}
/// On a narrow terminal the hint gives up its tail first, and says nothing rather than half a
/// phrase when even the commands will not fit. A running turn has the row, and so does a review
/// invitation, which is about something that happened.
#[test]
fn the_first_steps_hint_shortens_from_its_tail_and_gives_way() {
let height = 30;
let row_at = |width: u16, app: &mut App| {
let backend = test_backend(width, height);
app.update(Msg::TerminalResized { width, height });
row_above_composer(&render_app(app, &backend), width, height).0
};
let mut app = create_app();
let medium = row_at(80, &mut app);
assert!(medium.contains("shift+tab for plan mode · / or ctrl+k for commands"), "{medium:?}");
assert!(!medium.contains('@'), "the tail goes first: {medium:?}");
let narrow = row_at(40, &mut app);
assert!(narrow.contains("shift+tab for plan mode") && !narrow.contains('/'), "{narrow:?}");
let tiny = row_at(22, &mut app);
assert!(!tiny.contains("for comm") && !tiny.contains("shift"), "no half phrases: {tiny:?}");
app.status.flash_toast("Copied to clipboard");
let toasted = row_at(140, &mut app);
assert!(toasted.contains("Copied") && !toasted.contains("for commands"), "{toasted:?}");
app.status.toast = None;
app.status.state = luxe_tui::app::AppState::Streaming;
let running = row_at(140, &mut app);
assert!(!running.contains("for commands"), "a running turn owns the row: {running:?}");
}
/// The footer keeps to the keys a reader works with. The reading toggles — layout, guide,
/// churn — are listed by help, and a footer that also carried them stopped being read at all.
#[test]
fn the_footer_keeps_to_the_keys_that_work() {
let (width, height) = (200, 30);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &test_backend(width, height));
// The diff pane's share of the row: the rail's foot sits beside it, across the rule
let row = row_text(&buffer, height - 1, width);
let footer = row.rsplit('│').next().unwrap_or_default();
assert_eq!(
footer.trim(),
"space next · c comment · a ask agent · alt+enter finish · ? help",
"{footer}"
);
}
/// Scrolling clamps at the file's last row, and the pane draws one file at a time — so without a
/// marker there, hitting the bottom is indistinguishable from a scroll that stopped working.
#[test]
fn the_bottom_of_a_file_says_so_when_the_chapter_carries_on() {
let (width, height) = (140, 30);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewLarge).unwrap();
app.update(Msg::TerminalResized { width, height });
// The first chapter owns several files, so the first file's end is not the chapter's end.
for _ in 0..200 {
app.update(Msg::GuidedReviewLineNext);
}
let text = buffer_to_string(&render_app(&mut app, &test_backend(width, height)));
assert!(text.contains("end of file"), "the bottom of the file is named: {text}");
assert!(text.contains("— end of file —"), "and nothing else, mid-chapter: {text}");
}
/// Stepping to a chapter's last stop is what records it reviewed; scrolling there is not. The
/// end-of-reading marker is the only place that distinction becomes visible.
#[test]
fn the_end_of_a_chapter_says_whether_it_was_reviewed() {
let (width, height) = (120, 30);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
for _ in 0..60 {
app.update(Msg::GuidedReviewLineNext);
}
let scrolled = buffer_to_string(&render_app(&mut app, &test_backend(width, height)));
assert!(
scrolled.contains("end of the last chapter"),
"scrolling to the end is not reviewing it: {scrolled}"
);
for _ in 0..6 {
app.update(Msg::GuidedReviewHunkNext);
}
let stepped = buffer_to_string(&render_app(&mut app, &test_backend(width, height)));
assert!(stepped.contains("last chapter reviewed"), "stepping through it records it: {stepped}");
}
/// The fold controls describe churn. A review that has none is the common case for a
/// feature-sized change, and offering `f`/`d` there taught the reviewer that pressing a key
/// named on screen can do nothing at all — which costs every other key its credibility.
#[test]
fn the_fold_controls_appear_only_where_there_is_churn_to_fold() {
let (width, height) = (120, 30);
let mut clean = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
clean.update(Msg::TerminalResized { width, height });
let text = buffer_to_string(&render_app(&mut clean, &test_backend(width, height)));
assert!(!text.contains("f opens them"), "nothing mechanical, so no fold control: {text}");
assert!(!text.contains("d why"), "and nothing for it to explain: {text}");
assert!(text.contains("space next"), "the working controls stay: {text}");
let mut noisy = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
noisy.update(Msg::TerminalResized { width, height });
let text = buffer_to_string(&render_app(&mut noisy, &test_backend(width, height)));
assert!(text.contains("f opens them"), "a formatting-only hunk earns the control: {text}");
}
/// Prints the FILES section so its shape can be reviewed as text, without a screenshot.
#[test]
fn dock_changes_shape_snapshot() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("luxe");
let file = |path: &str, status: FileChangeStatus, a: Option<u64>, d: Option<u64>| {
FileChangeSummary { path: path.into(), status, additions: a, deletions: d, binary: false }
};
snapshot.changes = WorkspaceChangesSummary {
files: vec![
file("crates/luxe-core/src/usage.rs", FileChangeStatus::Added, Some(214), Some(0)),
file(
"crates/luxe-core/src/engine/usage.rs",
FileChangeStatus::Added,
Some(160),
Some(0),
),
file(
"crates/luxe-core/src/engine/turn.rs",
FileChangeStatus::Modified,
Some(18),
Some(24),
),
file(
"crates/luxe-core/src/engine/compact.rs",
FileChangeStatus::Modified,
Some(14),
Some(2),
),
file(
"crates/luxe-tui/src/view/dock.rs",
FileChangeStatus::Modified,
Some(96),
Some(31),
),
file(
"crates/luxe-tui/src/app/status.rs",
FileChangeStatus::Modified,
Some(41),
Some(48),
),
file("crates/luxe-tui/src/cost_report.rs", FileChangeStatus::Added, Some(131), Some(0)),
file(
"docs/design/a-very-long-design-document-name.md",
FileChangeStatus::Untracked,
Some(402),
Some(0),
),
file("assets/logo.png", FileChangeStatus::Added, None, None),
],
total_files: 9,
additions: Some(1076),
deletions: Some(105),
truncated: false,
};
app.workspace = Some(snapshot);
let buffer = render_app(&mut app, &backend);
println!("\n=== mixed roots ===\n{}", changes_block(&buffer, height));
// Everything under one root: the prefix is said once and the headings shorten.
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("luxe");
snapshot.changes = WorkspaceChangesSummary {
files: vec![
file("crates/luxe-core/src/usage.rs", FileChangeStatus::Added, Some(214), Some(0)),
file(
"crates/luxe-core/src/engine/turn.rs",
FileChangeStatus::Modified,
Some(18),
Some(24),
),
file(
"crates/luxe-tui/src/view/dock.rs",
FileChangeStatus::Modified,
Some(96),
Some(31),
),
],
total_files: 3,
additions: Some(328),
deletions: Some(55),
truncated: false,
};
app.workspace = Some(snapshot);
let buffer = render_app(&mut app, &backend);
let shared = changes_block(&buffer, height);
println!("\n=== shared root ===\n{shared}");
assert!(shared.contains("crates"), "one folder heads the tree: {shared}");
assert!(shared.contains("luxe-core/src"), "a lone chain is one row: {shared}");
assert!(shared.contains("usage.rs"), "files are named: {shared}");
}
/// The FILES block as plain text, for reviewing its shape without a screenshot.
pub(super) fn changes_block(buffer: &Buffer, height: u16) -> String {
(0..height)
.map(|y| row_text(buffer, y, 42).trim_end().to_string())
.skip_while(|line| !line.contains("FILES"))
.take_while(|line| !line.contains("MODEL"))
.filter(|line| !line.is_empty())
.collect::<Vec<_>>()
.join("\n")
}
/// Prints the guide pane so its shape can be reviewed as text, without a screenshot.
#[test]
fn guide_pane_shape_snapshot() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewBrief).unwrap();
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &backend);
let guide_width = luxe_tui::workspace_layout::guide_pane_width(width);
let guide: Vec<String> =
(0..height).map(|y| row_text(&buffer, y, guide_width).trim_end().to_string()).collect();
println!("\n{}", guide.join("\n").trim_end());
assert!(guide.iter().any(|line| line.contains("REVIEW")), "the pane names itself");
assert!(guide.iter().any(|line| line.contains("Step ")), "and says where you are");
}
/// An untracked *directory* is one dock row and several review files, so comparing counts made
/// "Workspace changed" permanently true over a review that matched the working tree exactly.
#[test]
fn a_pinned_review_that_matches_the_working_tree_is_not_called_stale() {
let (width, height) = (170, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let mut snapshot = empty_workspace("staleness");
// Git collapses the untracked directory; the review lists the one file inside it.
snapshot.changes = WorkspaceChangesSummary {
files: vec![FileChangeSummary {
path: "src/".into(),
status: FileChangeStatus::Untracked,
additions: None,
deletions: None,
binary: false,
}],
total_files: 1,
additions: None,
deletions: None,
truncated: false,
};
app.workspace = Some(snapshot.clone());
let matching = buffer_to_string(&render_app(&mut app, &backend));
assert!(
!matching.contains("Workspace changed"),
"the review covers exactly what the dock reports: {matching}"
);
// A file the review has never heard of *is* a real divergence.
snapshot.changes.files.push(FileChangeSummary {
path: "src/elsewhere.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(1),
deletions: Some(0),
binary: false,
});
snapshot.changes.total_files = 2;
app.workspace = Some(snapshot);
let moved = buffer_to_string(&render_app(&mut app, &backend));
assert!(moved.contains("Workspace changed"), "real drift still says so: {moved}");
}

View File

@@ -0,0 +1,172 @@
//! Images — inline captures at each fidelity tier.
use super::*;
/// A PNG whose halves are different colors, so a rasterized cell is checkable.
pub(super) fn split_png(width: u32, height: u32) -> String {
use base64::Engine as _;
let mut pixels = image::RgbaImage::new(width, height);
let midpoint = height / 2;
for (_, y, pixel) in pixels.enumerate_pixels_mut() {
*pixel = if y < midpoint {
image::Rgba([220, 40, 40, 255])
} else {
image::Rgba([40, 60, 220, 255])
};
}
let mut png = std::io::Cursor::new(Vec::new());
image::DynamicImage::ImageRgba8(pixels)
.write_to(&mut png, image::ImageFormat::Png)
.expect("encode png");
base64::engine::general_purpose::STANDARD.encode(png.into_inner())
}
/// A store drawing at `tier` against cells of a known size, so the geometry is not the host's.
pub(super) fn pinned_store(tier: luxe_tui::graphics::ImageTier) -> luxe_tui::graphics::ImageStore {
luxe_tui::graphics::ImageStore::new(
tier,
luxe_tui::graphics::CellSize { width: 10, height: 20 },
)
}
/// An app holding one pasted image, drawn at `tier`.
pub(super) fn app_with_image(tier: luxe_tui::graphics::ImageTier) -> App {
let mut app = create_app();
app.images = pinned_store(tier);
let key = app.attachment_image_key();
let origin = app.image_origin("pasted image", None);
assert!(app.intern_image(&key, &split_png(320, 160), origin));
app.push_convo(ConvoBlock::Image { key, width: 320, height: 160 });
app
}
pub(super) fn rows_of(buffer: &Buffer) -> Vec<String> {
let width = buffer.area.width as usize;
buffer
.content
.chunks(width)
.map(|row| row.iter().map(|cell| cell.symbol().to_string()).collect())
.collect()
}
/// With images off — or on a terminal that cannot draw them — the reader still learns that there
/// was one and how big it was. An image nobody can show is a fact about the conversation.
#[test]
fn an_undrawable_image_is_still_named_in_words() {
let backend = test_backend(80, 24);
let mut app = app_with_image(luxe_tui::graphics::ImageTier::Text);
let buffer = render_app(&mut app, &backend);
let line = rows_of(&buffer)
.into_iter()
.find(|row| row.contains("pasted image"))
.expect("the image is named");
assert!(line.contains("320") && line.contains("160"), "with its size: {line:?}");
}
/// An image the store refused — unreadable, or past the size caps — must not render as a blank gap
/// the reader has no way to interpret.
#[test]
fn an_image_that_could_not_be_taken_in_says_so() {
let backend = test_backend(80, 24);
let mut app = create_app();
let key = app.attachment_image_key();
let origin = app.image_origin("pasted image", None);
assert!(!app.intern_image(&key, "not-base64-at-all!!", origin));
app.push_convo(ConvoBlock::Image { key, width: 320, height: 160 });
let buffer = render_app(&mut app, &backend);
assert!(
rows_of(&buffer).iter().any(|row| row.contains("image unavailable")),
"an image that could not be decoded is reported, not silently dropped"
);
}
/// The blocks tier draws the picture as ordinary colored cells: `▀` with the upper scanline as
/// foreground and the lower as background. Nothing else in the transcript can tell the difference,
/// which is exactly why it works in every terminal.
#[test]
fn the_blocks_tier_draws_the_image_as_colored_cells() {
let backend = test_backend(80, 24);
let mut app = app_with_image(luxe_tui::graphics::ImageTier::Blocks);
let buffer = render_app(&mut app, &backend);
let painted: Vec<_> = buffer.content.iter().filter(|cell| cell.symbol() == "▀").collect();
assert!(painted.len() > 40, "the image occupies real cells: {}", painted.len());
assert!(
painted.iter().any(|cell| matches!(cell.fg, ratatui::style::Color::Rgb(r, _, b) if r > b)),
"the red half of the source is on screen"
);
assert!(
painted.iter().any(|cell| matches!(cell.bg, ratatui::style::Color::Rgb(r, _, b) if b > r)),
"and so is the blue half"
);
}
/// The pixel tier writes placeholder cells the terminal resolves into an image: a real symbol and
/// a real foreground color, so ratatui's diff erases them like any other text. What this guards is
/// that no escape sequence is ever smuggled into a cell — cells the diff cannot reason about are
/// how an image gets left behind on screen after it scrolls away.
#[test]
fn the_pixel_tier_writes_only_addressable_cells() {
let backend = test_backend(80, 24);
let mut app = app_with_image(luxe_tui::graphics::ImageTier::Pixels);
let buffer = render_app(&mut app, &backend);
let placeholders: Vec<_> =
buffer.content.iter().filter(|cell| cell.symbol().starts_with('\u{10EEEE}')).collect();
assert!(placeholders.len() > 40, "the image occupies real cells: {}", placeholders.len());
assert!(
placeholders.iter().all(|cell| matches!(cell.fg, ratatui::style::Color::Rgb(..))),
"every image cell names its image through a foreground color"
);
for cell in buffer.content.iter() {
assert!(!cell.symbol().contains('\u{1b}'), "no escape sequence reaches the cell buffer");
}
assert!(
app.images.drain_control().contains("a=T,U=1"),
"and the image itself is owed to the stream, not to the buffer"
);
}
/// A screenshot's picture belongs to the call that produced it, and it is never behind the expand
/// toggle: for `screenshot` the image *is* the result.
#[test]
fn a_tool_cards_image_renders_without_being_expanded() {
use luxe_core::message::{ContentBlock, Message, Role, ToolOutput};
let backend = test_backend(100, 40);
let mut app = create_app();
app.images = pinned_store(luxe_tui::graphics::ImageTier::Blocks);
app.update(Msg::Engine(luxe_core::Event::SessionLoaded {
session_id: "session-a".into(),
messages: vec![],
}));
app.update(Msg::Engine(luxe_core::Event::ToolActivityUpdated(Box::new(
luxe_core::ToolActivity::running("session-a", "call-1", "screenshot", "mode=url", 1),
))));
app.update(Msg::Engine(luxe_core::Event::MessageCommitted {
session_id: "session-a".into(),
entry_id: luxe_core::session::EntryId("entry-1".into()),
message: Message {
role: Role::Tool,
content: vec![ContentBlock::ToolResult {
call_id: "call-1".into(),
content: vec![
ToolOutput::Text("Captured url (320x160)".into()),
ToolOutput::Image {
data: split_png(320, 160),
mime: "image/png".into(),
name: Some(".luxe/screenshots/shot-1.png".into()),
},
],
is_error: false,
}],
},
}));
assert!(!app.tool_output_expanded, "the card is collapsed");
let buffer = render_app(&mut app, &backend);
let painted = buffer.content.iter().filter(|cell| cell.symbol() == "▀").count();
assert!(painted > 40, "the screenshot is on screen anyway: {painted} cells");
}

View File

@@ -0,0 +1,340 @@
//! Layout — selection highlight, composer and statusline, and the dock beside or over the chat.
use super::*;
#[test]
fn selected_conversation_block_uses_visual_highlight_and_escape_clears_it() {
let (w, h) = (80, 24);
let backend = test_backend(w, h);
let mut app = create_app();
app.push_convo(ConvoBlock::User {
text: "selected text".into(),
attached: Vec::new(),
chips: Vec::new(),
});
app.selected_block = Some(0);
let selected_bg = app.theme_styles.selected_bg.bg.expect("selected background");
let buffer = render_app(&mut app, &backend);
let row = (0..h)
.find(|&y| row_text(&buffer, y, w).contains("selected text"))
.expect("selected message row");
assert!((0..w).any(|x| buffer[(x, row)].bg == selected_bg));
assert!(matches!(
route_key(&mut app, &key(KeyCode::Esc)),
RouteAction::Msg(message) if matches!(*message, Msg::Tick)
));
assert!(app.selected_block.is_none());
}
#[test]
fn composer_and_statusline_are_adjacent_distinct_surfaces() {
let (w, h) = (80, 24);
let backend = test_backend(w, h);
let mut app = create_app();
app.status.model = "gpt-4o".into();
app.status.git_branch = Some("main".into());
app.status.context_pct = 42.0;
app.status.context_window = 128_000;
app.editor.insert_text("hello");
let buffer = render_app(&mut app, &backend);
let composer: String = (h - 5..h).map(|row| row_text(&buffer, row, w)).collect();
assert!(!composer.contains("Status"));
assert!(!composer.contains("Input"));
assert!(composer.contains("│hello"), "input should start at the first inner cell");
assert!(composer.contains("gpt-4o"));
assert!(composer.contains("42.0%/128k"));
// The bar is flat now: no editor mode label, no powerline arrow separators.
assert!(!composer.contains("INSERT"), "mode label is gone: {composer:?}");
assert!(!composer.contains('\u{e0b0}'), "no left powerline separator");
assert!(!composer.contains('\u{e0b2}'), "no right powerline separator");
assert!(row_text(&buffer, h - 2, w).trim_start().starts_with('╰'));
let statusline = row_text(&buffer, h - 1, w);
assert!(statusline.contains("gpt-4o"), "model anchors the statusline row: {statusline:?}");
// Both draw flush to the terminal's edges, and line up with each other there
let corner_left =
(0..w).find(|&x| buffer[(x, h - 4)].symbol() == "╭").expect("composer top-left corner");
let corner_right = (0..w)
.rev()
.find(|&x| buffer[(x, h - 4)].symbol() == "╮")
.expect("composer top-right corner");
// Painted, not inked: a band opens on a pad cell, which is blank but carries the slab's color.
// The canvas is read off the empty transcript, since the bar now reaches column 0
let canvas = buffer[(0, 0)].bg;
let painted = |x: u16| buffer[(x, h - 1)].symbol() != " " || buffer[(x, h - 1)].bg != canvas;
let statusline_left = (0..w).find(|&x| painted(x)).expect("statusline left content");
let statusline_right = (0..w).rev().find(|&x| painted(x)).expect("statusline right content");
assert_eq!(corner_left, statusline_left, "statusline aligns with the prompt box left edge");
assert_eq!(corner_right, statusline_right, "statusline aligns with the prompt box right edge");
}
#[test]
fn standard_context_dock_overlays_the_configured_side_without_narrowing_the_footer() {
let (width, height) = (120, 32);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.dock.show();
app.status.model = "gpt-4o".into();
app.push_convo(ConvoBlock::Assistant("conversation remains primary".into()));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("PROJECT"), "missing Context overlay: {content}");
// Overlay is not side-by-side, so the statusline stays as the compact footer (auto). The
// model name anchors the bar's bottom row (there is no editor-mode label anymore).
assert!(
row_text(&buffer, height - 1, width).contains("gpt-4o"),
"footer should remain visible on the bottom row: {content}"
);
// Left is the default side, so the overlay hugs the left edge; the heading sits flush against
// it, matching the full-height dock.
let context_x =
(0..width).find(|&x| buffer[(x, 0)].symbol() == "P").expect("dock heading should render");
assert_eq!(
context_x, DOCK_HEADING_LEAD,
"overlay must occupy the leftmost dock cells by default"
);
}
/// The overlay dock owns its cells. A `Block` only restyles what is already in the buffer, so the
/// conversation underneath used to show through wherever a dock row was shorter than the line it
/// covered — recolored as dock text, which reads as garbled dock content rather than as chat.
#[test]
fn the_overlay_dock_covers_the_conversation_underneath_it() {
let (width, height) = (120, 32);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.dock.show();
// Long enough to run under the whole dock column on several rows.
app.push_convo(ConvoBlock::Assistant("BLEED ".repeat(40)));
app.workspace = Some(empty_workspace("dock-overlay-bleed"));
let buffer = render_app(&mut app, &backend);
let dock_width = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH;
for y in 0..height {
let covered: String = (0..dock_width).map(|x| buffer[(x, y)].symbol()).collect();
assert!(
!covered.contains("BLEED"),
"conversation text shows through the overlay on row {y}: {covered:?}"
);
}
}
#[test]
fn compact_context_dock_replaces_chat_and_hides_the_composer() {
let (width, height) = (78, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.dock.show();
app.status.model = "qwen3.8-27b".into();
app.status.context_window = 128_000;
app.status.context_pct = 42.0;
app.editor.insert_text("composer must stay hidden");
app.push_convo(ConvoBlock::Assistant("chat must stay hidden".into()));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("PROJECT"), "missing replacement Context surface: {content}");
assert!(content.contains("CONTEXT"), "Context footer should replace editor mode: {content}");
assert!(
content.contains("pgup/Dn scroll"),
"footer should explain independent Context scrolling: {content}"
);
assert!(content.contains("esc"), "footer should explain how to return to chat: {content}");
assert!(!content.contains("chat must stay hidden"), "chat leaked into replacement: {content}");
assert!(
!content.contains("composer must stay hidden"),
"composer leaked into replacement: {content}"
);
let context_x =
(0..width).find(|&x| buffer[(x, 0)].symbol() == "P").expect("dock heading should render");
assert_eq!(
context_x, DOCK_HEADING_LEAD,
"the heading badge's leading edge sits on the terminal's edge"
);
}
#[test]
fn wide_context_dock_is_a_full_height_left_panel_and_hides_the_statusline() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.push_convo(ConvoBlock::Assistant("conversation remains primary".into()));
let mut snapshot = WorkspaceSnapshot::empty(
WorkspaceScopeId::new("dock-render"),
ProjectIdentity {
root: "/work/luxe".into(),
display_name: "luxe".into(),
display_path: "~/work/luxe".into(),
git_branch: Some("feature/context-dock".into()),
git_dirty: true,
git_head: None,
},
);
snapshot.session = Some(WorkspaceSessionSummary {
id: "session-1".into(),
title: "Render the Context Dock".into(),
updated_at_ms: 1,
});
snapshot.todos = TodoSummary {
current: Some(TodoSummaryItem {
id: "2".into(),
subject: "Render the Context Plan".into(),
status: TodoSummaryStatus::InProgress,
blocked_by: Vec::new(),
}),
items: vec![
TodoSummaryItem {
id: "2".into(),
subject: "Render the Context Plan".into(),
status: TodoSummaryStatus::InProgress,
blocked_by: Vec::new(),
},
TodoSummaryItem {
id: "3".into(),
subject: "Capture responsive fixtures".into(),
status: TodoSummaryStatus::Blocked,
blocked_by: vec!["2".into()],
},
TodoSummaryItem {
id: "4".into(),
subject: "Write the dock tests".into(),
status: TodoSummaryStatus::Pending,
blocked_by: Vec::new(),
},
TodoSummaryItem {
id: "1".into(),
subject: "Model the sections".into(),
status: TodoSummaryStatus::Completed,
blocked_by: Vec::new(),
},
],
pending: 1,
in_progress: 1,
completed: 3,
blocked: 1,
total: 8,
truncated: true,
};
snapshot.changes = WorkspaceChangesSummary {
files: vec![
FileChangeSummary {
path: "crates/luxe-tui/src/view/dock.rs".into(),
status: FileChangeStatus::Modified,
additions: Some(12),
deletions: Some(3),
binary: false,
},
FileChangeSummary {
path: "assets/context-preview.png".into(),
status: FileChangeStatus::Added,
additions: None,
deletions: None,
binary: true,
},
],
total_files: 4,
additions: None,
deletions: None,
truncated: true,
};
snapshot.review = Some(ReviewSummary {
id: "review-1".into(),
title: "Fix the stale reference".into(),
source: "last turn".into(),
unresolved_findings: 1,
completed_at_ms: 2,
});
snapshot.tooling.debug_sessions = vec![DebugSessionStatus {
id: "dbg-1".into(),
adapter: "codelldb".into(),
program: "target/debug/app".into(),
terminated: false,
stopped: true,
stop_reason: Some("breakpoint".into()),
}];
app.workspace = Some(snapshot);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("conversation remains primary"), "missing transcript: {content}");
assert!(content.contains("PROJECT"), "missing identity heading: {content}");
// Identity is project + branch only: the auto-derived session title and the task slug were
// dropped as chrome that restated what the user already knew.
assert!(!content.contains("Session ·"), "session title row was dropped: {content}");
assert!(!content.contains("Task ·"), "task slug row was dropped: {content}");
// The badge holds the word and the ratio rides bare beside it, so the run of headings down the
// rail stays one kind of object — hence the closing cap between the two.
assert!(content.contains("PLAN"), "missing the Plan heading: {content}");
assert!(content.contains("3/8"), "Plan heading carries the ratio: {content}");
// Every todo is its own checklist row, in-progress first, with per-status glyphs.
assert!(content.contains("◉ Render the Context Plan"), "in-progress row: {content}");
// The blocked row is its mark and its subject: the ids it waits on are shown nowhere else
assert!(content.contains("⊘ Capture responsive fixtu"), "blocked row: {content}");
assert!(!content.contains("needs"), "no dependency note: {content}");
assert!(content.contains("○ Write the dock tests"), "a pending row: {content}");
assert!(content.contains("✓ Model the sections"), "a completed row: {content}");
assert!(content.contains("├─") || content.contains("└─"), "tree connectors: {content}");
// What a list is not showing is the bar's to say: the rail counts none of it in words.
assert!(!content.contains("not listed"), "the rail counts nothing in words: {content}");
assert!(!content.contains("more"), "and folds nothing into a tail: {content}");
assert!(!content.contains("Open Plan"), "the dock must not advertise a phantom action");
assert!(content.contains("FILES"), "missing the Files heading: {content}");
// With no prior review the headline *is* the total, said once.
assert!(content.contains("4 changed"), "missing the changes headline: {content}");
assert!(!content.contains("in the worktree"), "the total is not said twice: {content}");
assert!(
content.contains("ctrl+g review"),
"the Changes section names the way into review: {content}"
);
assert!(content.contains("ctrl+p preview"), "and the cheaper way in beside it: {content}");
// The rail carries what the reader can act on. A review's open comments and a live debug
// session are both true here and both stay off it: neither is reachable from the rail, and the
// debugger is the agent's tool — `/debug` answers on demand, as `/lsp` does.
assert!(!content.contains("REVIEW"), "no review section: {content}");
assert!(!content.contains("open comment"), "and no comment count: {content}");
assert!(!content.contains("DEBUG"), "no debug section: {content}");
assert!(!content.contains("stopped: breakpoint"), "and no session state: {content}");
assert!(
!content.contains("LOOP"),
"loop gate must not surface in the interactive dock: {content}"
);
assert!(!content.contains("Gate ·"), "gate verdict must not surface: {content}");
// The dock has no selection highlight or collapse markers anymore.
assert!(!content.contains("▶"), "informational dock shows no collapse markers: {content}");
// The full-height sidebar carries context on wide terminals, so the statusline auto-hides and
// the composer bottom-aligns to the final body row (no compact bar beneath it).
let composer_x = luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH
+ luxe_tui::workspace_layout::CONTEXT_DOCK_SEPARATOR_WIDTH
+ 1;
assert_eq!(
buffer[(composer_x, height - 1)].symbol(),
"╰",
"statusline should be hidden beside the sidebar: {content}"
);
// The sidebar is a full-height LEFT column: its heading opens on the first row and the panel
// still occupies the top and bottom rows of the viewport.
let context_x =
(0..width).find(|&x| buffer[(x, 0)].symbol() == "P").expect("dock heading should render");
assert_eq!(
context_x, DOCK_HEADING_LEAD,
"left dock heading badge opens on the terminal's edge"
);
// The left rail is followed by its separator, and both span the whole viewport height:
// the divider glyph is present on the very first and very last rows.
let sep_x = usize::from(luxe_tui::workspace_layout::CONTEXT_DOCK_WIDTH);
assert_eq!(buffer[(sep_x as u16, 0)].symbol(), "│", "separator missing on the top row");
assert_eq!(
buffer[(sep_x as u16, height - 1)].symbol(),
"│",
"separator should reach the bottom row (full-height sidebar)"
);
}

View File

@@ -0,0 +1,63 @@
//! Render test: verify the view renders correctly without a real terminal.
//!
//! Uses ratatui's TestBackend to render into an in-memory buffer.
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use luxe_core::config::{Config, ConversationAlignment};
use luxe_core::guided_review::{ReviewLine, ReviewLineKind};
use luxe_core::keymap::KeyMap;
use luxe_core::{
DebugSessionStatus, DiagnosticsSummary, FileChangeStatus, FileChangeSummary, FileDiagnostics,
ProjectIdentity, ReviewSummary, SessionSummary as WorkspaceSessionSummary, TodoSummary,
TodoSummaryItem, TodoSummaryStatus, ToolActivity, ToolActivityState, WorkspaceChangesSummary,
WorkspaceScopeId, WorkspaceSnapshot,
};
use luxe_tui::app::input::review_keys::claim;
use luxe_tui::app::{App, ConvoBlock, Msg, ToolItem, ViewMode};
use luxe_tui::clipboard::ClipboardSink;
use luxe_tui::dashboard::{DashboardState, SessionSummary};
use luxe_tui::fixture::{seeded_app, FixtureScenario};
use luxe_tui::main_loop::{route_key, route_mouse, route_mouse_at, RouteAction};
use luxe_tui::session_picker::{SessionEntry, SessionPickerState};
use luxe_tui::view::render;
use luxe_tui::workspace_dock::DockList;
use ratatui::backend::TestBackend;
use ratatui::buffer::Buffer;
use ratatui::Terminal;
mod activity;
mod canvas;
mod cards;
mod changes;
mod changes_pane;
mod chat_keys;
mod clicks;
mod composer;
mod dock;
mod elsewhere;
mod files;
mod hints;
mod images;
mod layout;
mod peek_selection;
mod pickers;
mod reasoning;
mod reveal;
mod review_context;
mod review_guide;
mod routing;
mod selection;
mod steering;
mod support;
mod transcript;
use activity::*;
use canvas::*;
use cards::*;
use changes::*;
use composer::*;
use dock::*;
use elsewhere::*;
use images::*;
use routing::*;
use support::*;

View File

@@ -0,0 +1,167 @@
//! Peek selection — text selected with the mouse in the Changes pane, by the character.
use super::*;
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
use luxe_tui::fixture::seed_file_view;
const FILE: &str = "fn alpha() {\n\tlet bravo = 1;\n}\n";
/// A File view on `text`, drawn once so the pointer has something to land on.
fn file_view(text: &str, width: u16, height: u16) -> (App, TestBackend, Buffer) {
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
seed_file_view(&mut app, "src/lib.rs", text, None);
let buffer = render_app(&mut app, &backend);
(app, backend, buffer)
}
fn mouse(app: &mut App, kind: MouseEventKind, (column, row): (u16, u16)) {
let event = MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let action = route_mouse(app, &event);
apply(app, action);
}
/// Presses at `from`, drags to `to` and lets go.
fn drag(app: &mut App, from: (u16, u16), to: (u16, u16)) {
mouse(app, MouseEventKind::Down(MouseButton::Left), from);
mouse(app, MouseEventKind::Drag(MouseButton::Left), to);
mouse(app, MouseEventKind::Up(MouseButton::Left), to);
}
/// Where `needle` first sits on screen, as `(column, row)`.
fn find(buffer: &Buffer, needle: &str, width: u16, height: u16) -> (u16, u16) {
let row = row_containing(buffer, needle, width, height);
(column_of(&row_text(buffer, row, width), needle), row)
}
/// A drag over the File view's code highlights the characters it covers and copies them on
/// release, as it does in the transcript. The code used to be only a line-pick target, so the same
/// drag picked the whole line instead.
#[test]
fn dragging_over_file_view_code_selects_and_copies_the_characters() {
let (width, height) = (100, 20);
let (mut app, backend, buffer) = file_view(FILE, width, height);
let (column, row) = find(&buffer, "bravo", width, height);
mouse(&mut app, MouseEventKind::Down(MouseButton::Left), (column, row));
mouse(&mut app, MouseEventKind::Drag(MouseButton::Left), (column + 5, row));
let buffer = render_app(&mut app, &backend);
let selected = app.theme_styles.selected_bg.bg.expect("a selection background");
assert_eq!(buffer[(column, row)].bg, selected, "the dragged code is highlighted");
assert_ne!(buffer[(column + 6, row)].bg, selected, "and nothing past it");
mouse(&mut app, MouseEventKind::Up(MouseButton::Left), (column + 5, row));
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert_eq!(app.outbox.copy.as_deref(), Some("bravo"));
assert!(!shown.contains("ask about"), "no lines were picked: {shown}");
}
/// A drag across lines copies the source between its ends: no line numbers, and the tab that
/// indents the second line comes back a tab rather than the spaces it is drawn as.
#[test]
fn a_drag_across_lines_copies_the_source_tabs_and_all() {
let (width, height) = (100, 20);
let (mut app, _backend, buffer) = file_view(FILE, width, height);
let start = find(&buffer, "alpha", width, height);
let (column, row) = find(&buffer, "bravo", width, height);
drag(&mut app, start, (column + 5, row));
assert_eq!(app.outbox.copy.as_deref(), Some("alpha() {\n\tlet bravo"));
}
/// The line numbers still pick whole lines, which is how a reader asks the agent about them.
#[test]
fn a_drag_down_the_line_numbers_still_picks_lines() {
let (width, height) = (100, 20);
let (mut app, backend, buffer) = file_view(FILE, width, height);
let (code, first) = find(&buffer, "fn alpha", width, height);
let (_, second) = find(&buffer, "bravo", width, height);
// The number, the keyboard's mark, the change bar and a space come before the code
let gutter = code - 4;
drag(&mut app, (gutter, first), (gutter, second));
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert!(shown.contains("ask about lines 1–2"), "the lines are picked: {shown}");
assert!(app.outbox.copy.is_none(), "and a pick copies nothing by itself");
}
/// A double-click on the File view's code takes the word under it, the way it does elsewhere.
#[test]
fn a_double_click_on_file_view_code_takes_the_word() {
let (width, height) = (100, 20);
let (mut app, backend, buffer) = file_view(FILE, width, height);
let (column, row) = find(&buffer, "bravo", width, height);
let now = std::time::Instant::now();
click_cell(&mut app, column + 2, row, now);
click_cell(&mut app, column + 2, row, now);
render_app(&mut app, &backend);
assert_eq!(app.outbox.copy.as_deref(), Some("bravo"));
}
/// A long line wraps, and a drag on a later row selects what that row shows, not the same columns
/// from the start of the line.
#[test]
fn a_drag_on_a_wrapped_row_selects_what_that_row_shows() {
let (width, height) = (90, 20);
let line = (0..60).map(|index| format!("w{index:03}")).collect::<Vec<_>>().join(" ");
let (mut app, _backend, buffer) = file_view(&line, width, height);
let (_, first) = find(&buffer, "w000", width, height);
// Whichever word sits whole on the row after the first, wherever the wrap fell
let text = row_text(&buffer, first + 1, width);
let word = (0..60)
.map(|index| format!("w{index:03}"))
.find(|word| text.contains(&format!("{word} ")))
.expect("the line wraps onto a second row");
let column = column_of(&text, &word);
drag(&mut app, (column, first + 1), (column + 4, first + 1));
assert_eq!(app.outbox.copy.as_deref(), Some(word.as_str()));
}
/// In a side-by-side diff a drag stays in the column it began in: down the new side it copies the
/// new file's lines and skips the deletion the old side draws beside them.
#[test]
fn a_drag_down_the_new_column_copies_only_new_code() {
let (width, height) = (260, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("peek-select-split", 2));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
assert!(split_row(&buffer, "fn sum() {", &app, width, height), "the diff is side by side");
let top = row_containing(&buffer, "fn sum() {", width, height);
let text = row_text(&buffer, top, width);
let (byte, _) = text.match_indices("fn sum() {").nth(1).expect("both columns show it");
let new_side = text[..byte].chars().count() as u16;
let (end, bottom) = find(&buffer, "let total = a - b;", width, height);
drag(&mut app, (new_side, top), (end + 18, bottom));
assert_eq!(app.outbox.copy.as_deref(), Some("fn sum() {\nlet total = a - b;"));
}
/// The unified diff selects the same way, across a deletion and the addition under it, and never
/// copies the line numbers or the `-`/`+` signs.
#[test]
fn a_drag_over_the_unified_diff_copies_its_code() {
let (width, height) = (90, 24);
let backend = test_backend(width, height);
let (mut app, mut rx) = create_app_with_engine();
app.update(Msg::TerminalResized { width, height });
app.dock.hide();
app.workspace = Some(changed_workspace("peek-select-unified", 2));
let path = "src/module00/file00.rs";
open_changes_with(&mut app, &mut rx, path, Some(one_hunk_file(path)));
let buffer = render_app(&mut app, &backend);
assert!(!split_row(&buffer, "fn sum() {", &app, width, height), "the diff is unified");
let start = find(&buffer, "let total = a + b;", width, height);
let (end, bottom) = find(&buffer, "let total = a - b;", width, height);
drag(&mut app, start, (end + 18, bottom));
assert_eq!(app.outbox.copy.as_deref(), Some("let total = a + b;\nlet total = a - b;"));
}

View File

@@ -0,0 +1,177 @@
//! Pickers — the thinking, palette and slash rows answer a click.
use super::*;
/// Picker clicks (plan B4): clicking a thinking-level row selects + applies it (closing the
/// picker) via the shared accept path.
#[test]
fn clicking_a_thinking_level_row_applies_and_closes_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.open_thinking_picker();
assert!(app.overlays.thinking_picker.is_some(), "picker opens");
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Medium"))
.expect("a thinking-level row renders");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: width / 2,
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => app.update(*message),
other => panic!("expected a synthetic-accept message from the click, got {other:?}"),
}
assert!(app.overlays.thinking_picker.is_none(), "clicking a level applies and closes it");
}
/// The picker only offers what the active model accepts: a level it can't honor is labeled and
/// dimmed, the cursor jumps over it, a click on it does nothing, and the frame names the model the
/// annotations belong to.
#[test]
fn the_thinking_picker_disables_levels_the_model_cannot_honor() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
use luxe_core::provider::{ModelInfo, ThinkingLevel};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
// An extended-thinking Claude: it reasons, but there is no xhigh or ultra to ask for.
app.set_model_catalog(
Vec::new(),
Some(ModelInfo {
display_name: Some("Claude Sonnet 4.5".to_string()),
reasoning: true,
thinking_level_map: std::collections::HashMap::from([
("high".to_string(), Some("high".to_string())),
("xhigh".to_string(), None),
("ultra".to_string(), None),
]),
..Default::default()
}),
);
app.open_thinking_picker();
let buffer = render_app(&mut app, &backend);
let screen = buffer_to_string(&buffer);
assert!(screen.contains("Claude Sonnet 4.5"), "the frame names the model: {screen}");
// Rows sit inside the modal frame behind a cursor gutter, so strip the chrome before matching.
let level_row = |label: &str| {
(0..height)
.find(|&y| {
row_text(&buffer, y, width)
.trim_start()
.trim_start_matches(['│', '❯', ' '])
.starts_with(label)
})
.unwrap_or_else(|| panic!("no row for {label}: {screen}"))
};
assert!(
!row_text(&buffer, level_row("Medium"), width).contains("not supported"),
"a level the model honors carries no note"
);
for label in ["X-High", "Ultra"] {
assert!(
row_text(&buffer, level_row(label), width).contains("not supported"),
"{label} must be labeled unsupported: {screen}"
);
}
let click = |row| MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: width / 2,
row,
modifiers: KeyModifiers::NONE,
};
assert!(
matches!(route_mouse(&mut app, &click(level_row("Ultra"))), RouteAction::None),
"clicking an unsupported level does nothing"
);
assert!(app.overlays.thinking_picker.is_some(), "the picker stays open");
match route_mouse(&mut app, &click(level_row("Medium"))) {
RouteAction::Msg(message) => app.update(*message),
other => panic!("a supported level should accept the click, got {other:?}"),
}
assert!(app.overlays.thinking_picker.is_none(), "a supported level applies and closes it");
assert_eq!(app.status.thinking, ThinkingLevel::Medium);
}
/// Palette clicks (plan B5): clicking a palette row moves the selection there and dispatches it
/// via the shared accept path, closing the palette.
#[test]
fn clicking_a_palette_row_dispatches_and_closes_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (120, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
// Ctrl+K opens the command palette.
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL)));
assert!(app.overlays.palette.is_some(), "ctrl+k opens the palette");
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Change theme"))
.expect("a palette command row renders");
// On the words, since the pane beside the list is not a row
let column = row_text(&buffer, row, width).find("Change theme").expect("found above") as u16;
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column,
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => app.update(*message),
other => panic!("expected a synthetic-accept message from the click, got {other:?}"),
}
assert!(app.overlays.palette.is_none(), "clicking a palette row dispatches and closes it");
assert!(app.overlays.theme_picker.is_some(), "and runs the row that was clicked");
}
/// Slash-flyout clicks: clicking a flyout row accepts it via the shared path, and accepting
/// **runs** the command.
///
/// `/diff` takes an optional target, and picking it used to complete `"/diff "` into the composer
/// and stop — which reads as nothing having happened, and was reported as exactly that. Tab is the
/// key for completing an argument; Enter and a click run the command's bare form.
#[test]
fn clicking_a_slash_flyout_row_accepts_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (120, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE)));
assert!(app.overlays.slash_flyout.is_some(), "typing / opens the slash flyout");
// Filter down to it rather than trusting its position: the flyout shows a bounded window, so
// asserting against the unfiltered list makes this test fail whenever a command is added
// anywhere above `/diff`.
for character in "dif".chars() {
app.update(Msg::Key(KeyEvent::new(KeyCode::Char(character), KeyModifiers::NONE)));
}
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Review changes"))
.expect("the /diff (Review changes) flyout row renders");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 20,
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => app.update(*message),
other => panic!("expected a synthetic-accept message from the click, got {other:?}"),
}
assert!(app.overlays.slash_flyout.is_none(), "accepting closes the flyout");
assert_eq!(app.editor.current_input(), "", "accepting runs the command and clears the draft");
}

View File

@@ -0,0 +1,133 @@
//! Reasoning — a reasoning block keeps its shape as it commits.
use super::*;
/// Streams `parts` as reasoning deltas, one per provider block index.
pub(super) fn stream_reasoning(app: &mut App, parts: &[(usize, &str)]) {
for (block, delta) in parts {
app.update(Msg::Engine(luxe_core::Event::ThinkingDelta {
block: *block,
delta: (*delta).to_string(),
}));
}
}
pub(super) fn commit_reasoning(app: &mut App, parts: &[&str], answer: Option<&str>) {
use luxe_core::message::{ContentBlock, Message, Role};
let mut content: Vec<ContentBlock> = parts
.iter()
.map(|text| ContentBlock::Thinking {
text: (*text).to_string(),
signature: None,
id: None,
encrypted: None,
opaque: None,
})
.collect();
if let Some(answer) = answer {
content.push(ContentBlock::Text(answer.to_string()));
}
app.update(Msg::Engine(luxe_core::Event::MessageCommitted {
session_id: "s".into(),
entry_id: luxe_core::session::EntryId("e1".into()),
message: Message { role: Role::Assistant, content },
}));
}
pub(super) fn chat_app() -> App {
let mut app = create_app();
app.update(Msg::Engine(luxe_core::Event::SessionLoaded {
session_id: "s".into(),
messages: vec![],
}));
app
}
/// The symptom, stated as the invariant: committing a message must not change what is on screen.
///
/// A message can carry several reasoning items. Core keeps one block per provider output index, so
/// if the stream reports them all as block 0 the front-end merges them into one item and the commit
/// has to tear the tail down and rebuild it — which the reader sees as the reasoning reflowing, its
/// spacing changing, under them.
#[test]
fn committing_a_multi_part_reasoning_message_does_not_reflow_it() {
let backend = test_backend(100, 40);
let mut app = chat_app();
let parts = ["**Verifying the capture**", "Checking whether the tool is loaded yet."];
stream_reasoning(&mut app, &[(0, parts[0]), (1, parts[1])]);
app.reveal_catch_up();
let streamed = rows_of(&render_app(&mut app, &backend));
commit_reasoning(&mut app, &parts, None);
app.reveal_catch_up();
let committed = rows_of(&render_app(&mut app, &backend));
assert_eq!(
streamed, committed,
"the transcript changed when the message committed — nothing about it should move"
);
assert_eq!(
app.convo.len(),
2,
"each reasoning item is its own block, streamed and committed alike"
);
}
/// Reasoning that carries no text is a replay token, not content: OpenAI returns an item holding
/// only `id`/`encrypted_content` whenever summaries are off. Drawing it would invent a block the
/// stream never produced — and inventing one is what forces the commit to rebuild the tail.
#[test]
fn reasoning_with_no_text_is_never_drawn_and_never_reflows() {
use luxe_core::message::{ContentBlock, Message, Role};
let backend = test_backend(100, 40);
let mut app = chat_app();
app.update(Msg::Engine(luxe_core::Event::TokenDelta { block: 0, delta: "Done.".into() }));
app.reveal_catch_up();
let streamed = rows_of(&render_app(&mut app, &backend));
app.update(Msg::Engine(luxe_core::Event::MessageCommitted {
session_id: "s".into(),
entry_id: luxe_core::session::EntryId("e1".into()),
message: Message {
role: Role::Assistant,
content: vec![
// The replay token: no summary text, only what must be sent back next turn.
ContentBlock::Thinking {
text: String::new(),
signature: None,
id: Some("rs_1".into()),
encrypted: Some("ENC==".into()),
opaque: None,
},
ContentBlock::Text("Done.".into()),
],
},
}));
app.reveal_catch_up();
assert_eq!(rows_of(&render_app(&mut app, &backend)), streamed, "nothing moved");
assert_eq!(app.convo.len(), 1, "the replay token is not a transcript item");
}
/// The ordinary case has to keep working: one reasoning item, then the answer, refreshed in place.
#[test]
fn a_single_reasoning_item_still_commits_in_place() {
let backend = test_backend(100, 40);
let mut app = chat_app();
stream_reasoning(&mut app, &[(0, "Thinking about it.")]);
app.update(Msg::Engine(luxe_core::Event::TokenDelta {
block: 0,
delta: "Here is the answer.".into(),
}));
app.reveal_catch_up();
let streamed = rows_of(&render_app(&mut app, &backend));
commit_reasoning(&mut app, &["Thinking about it."], Some("Here is the answer."));
app.reveal_catch_up();
assert_eq!(rows_of(&render_app(&mut app, &backend)), streamed);
assert_eq!(app.convo.len(), 2, "reasoning and answer, not duplicated");
}

View File

@@ -0,0 +1,602 @@
//! Reveal — streamed text paced onto the screen, and what never waits.
use super::*;
/// One provider lump, the size Anthropic actually delivers (~75 characters at a time).
pub(super) const LUMP: &str =
"alpha the provider hands you text in lumps and the render loop paints omega";
/// Characters of `text` a frame is showing, ignoring everything between them.
///
/// Letters only: wrapping breaks the text across rows, and the chrome those rows end with — a
/// scrollbar lane, a panel border — would otherwise interrupt the match.
pub(super) fn revealed_count(frame: &str, text: &str) -> usize {
let flat: String = frame.chars().filter(char::is_ascii_alphanumeric).collect();
let target: Vec<char> = text.chars().filter(char::is_ascii_alphanumeric).collect();
(0..=target.len())
.rev()
.find(|n| flat.contains(&target[..*n].iter().collect::<String>()))
.unwrap_or(0)
}
/// Runs the reveal forward the way the event loop does: one frame every 12 ms.
///
/// `at` is the frame the clock has reached and is advanced in place, so successive calls continue
/// rather than replaying from the start. Jumping the clock instead of stepping it would prove nothing
/// — a frame's timestep is capped precisely so that a suspended terminal cannot dump the whole buffer
/// on its next frame.
pub(super) fn advance_frames(
app: &mut App,
backend: &TestBackend,
base: std::time::Instant,
at: &mut u32,
frames: u32,
) -> String {
let mut painted = String::new();
for _ in 0..frames {
*at += 1;
app.status.frame_clock = Some(base + std::time::Duration::from_millis(12) * *at);
painted = buffer_to_string(&render_app(app, backend));
}
painted
}
/// Streamed prose is paced onto the screen instead of landing in the provider's lumps.
#[test]
fn streamed_prose_is_revealed_as_it_is_paced() {
let backend = test_backend(60, 20);
let mut app = create_app();
let base = std::time::Instant::now();
app.status.frame_clock = Some(base);
let total = LUMP.chars().filter(|c| !c.is_whitespace()).count();
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta { block: 0, delta: LUMP.into() }));
let mut at = 0;
// Nothing yet: the reveal gathers a buffer before its first paint, rather than showing the
// opening characters and freezing until the next arrival lands.
let first = buffer_to_string(&render_app(&mut app, &backend));
assert_eq!(revealed_count(&first, LUMP), 0, "the first paint waits for a buffer: {first}");
// Past the priming ceiling it starts painting — and paces, rather than dropping the lot.
let started = advance_frames(&mut app, &backend, base, &mut at, 45);
let seen = revealed_count(&started, LUMP);
assert!(seen > 0, "painting has started: {started}");
assert!(seen < total, "but it stays behind the text that arrived: {seen} of {total}");
// A few frames on, more of it has resolved.
let midway = advance_frames(&mut app, &backend, base, &mut at, 10);
let more = revealed_count(&midway, LUMP);
assert!(more > seen, "the reveal advances with the clock: {more} vs {seen}");
// The turn ends, so nothing more can arrive: the buffer drains to its deadline.
app.update(Msg::Engine(luxe_core::event::Event::TurnEnded {
reason: luxe_core::event::StopReason::EndTurn,
}));
let done = advance_frames(&mut app, &backend, base, &mut at, 60);
assert_eq!(revealed_count(&done, LUMP), total, "a finished message is all there: {done}");
assert!(!app.reveal.pending(), "and the reveal has nothing left to show");
}
/// The ordering rule, end to end: a card cannot appear above prose that is still arriving.
#[test]
fn a_tool_card_waits_for_the_prose_above_it() {
let backend = test_backend(60, 20);
let mut app = create_app();
let base = std::time::Instant::now();
app.status.frame_clock = Some(base);
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta { block: 0, delta: LUMP.into() }));
let mut activity = ToolActivity::running("session-a", "call-read", "read", "src/lib.rs", 1);
activity.state = ToolActivityState::Succeeded;
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let held = buffer_to_string(&render_app(&mut app, &backend));
assert!(!held.contains("src/lib.rs"), "the card waits its turn: {held}");
// The card being there at all means the message is complete, so the prose drains and both land.
let mut at = 0;
let landed = advance_frames(&mut app, &backend, base, &mut at, 90);
assert!(landed.contains("src/lib.rs"), "and lands once the prose is done: {landed}");
assert_eq!(
revealed_count(&landed, LUMP),
LUMP.chars().filter(|c| !c.is_whitespace()).count(),
"with the prose complete above it: {landed}"
);
}
/// Reasoning shown as a one-line peek has nothing to type out, and must never gate what follows.
#[test]
fn collapsed_reasoning_is_never_paced() {
let config = Config {
conversation: luxe_core::config::ConversationConfig {
thinking: Some(luxe_core::config::ThinkingDisplay::Collapsed),
..Default::default()
},
..Default::default()
};
let backend = test_backend(60, 20);
let mut app = create_app_with_config(config);
app.status.frame_clock = Some(std::time::Instant::now());
app.update(Msg::Engine(luxe_core::event::Event::ThinkingDelta {
block: 0,
delta: "weighing the options before answering".into(),
}));
let frame = buffer_to_string(&render_app(&mut app, &backend));
assert!(frame.contains("weighing the options"), "the peek is drawn at once: {frame}");
}
/// `stream_reveal: off` is a real off: the same instant paint as before the reveal existed.
#[test]
fn stream_reveal_off_paints_every_arrival_immediately() {
let config = Config {
conversation: luxe_core::config::ConversationConfig {
stream_reveal: Some(luxe_core::config::StreamReveal::Off),
..Default::default()
},
..Default::default()
};
let backend = test_backend(60, 20);
let mut app = create_app_with_config(config);
app.status.frame_clock = Some(std::time::Instant::now());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta { block: 0, delta: LUMP.into() }));
let frame = buffer_to_string(&render_app(&mut app, &backend));
assert!(frame.contains("alpha") && frame.contains("omega"), "all of it, at once: {frame}");
}
/// Anything that needs the user stops animating around them.
#[test]
fn a_permission_prompt_shows_everything_that_arrived() {
let backend = test_backend(60, 24);
let mut app = create_app();
app.status.frame_clock = Some(std::time::Instant::now());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta { block: 0, delta: LUMP.into() }));
let total = LUMP.chars().filter(char::is_ascii_alphanumeric).count();
let held = buffer_to_string(&render_app(&mut app, &backend));
assert!(revealed_count(&held, LUMP) < total, "mid-reveal to begin with: {held}");
app.update(Msg::Engine(luxe_core::event::Event::PermissionRequested {
id: luxe_core::permission::PermissionRequestId::new(),
session_id: "session-a".into(),
tool: "bash".into(),
permission: "bash".into(),
summary: "Run: rm -rf /etc".into(),
always_patterns: Vec::new(),
}));
let asked = buffer_to_string(&render_app(&mut app, &backend));
assert!(asked.contains("Permission required"), "the prompt is up: {asked}");
// Nothing is held back behind it either — dismissing it has to reveal a whole message rather
// than the half sentence the reveal happened to be on.
assert!(!app.reveal.pending(), "a question is not asked over text that is still arriving");
app.update(Msg::Engine(luxe_core::event::Event::TurnEnded {
reason: luxe_core::event::StopReason::EndTurn,
}));
let answered = buffer_to_string(&render_app(&mut app, &backend));
assert_eq!(revealed_count(&answered, LUMP), total, "all of it is there: {answered}");
}
/// A prompt grows up from the composer over a `Clear`, so it used to paint out whatever the
/// transcript had last drawn there — which is the output it is asking about. The conversation
/// stands down by the rows the panel takes instead, and both are readable at once.
#[test]
fn a_prompt_above_the_composer_does_not_cover_the_output_that_prompted_it() {
let backend = test_backend(60, 30);
let ask = |app: &mut App, event| {
app.update(Msg::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)));
app.update(Msg::Engine(event));
buffer_to_string(&render_app(app, &backend))
};
let mut app = create_app();
// Longer than the viewport, so the tail sits at the bottom whichever way the transcript grows.
for index in 0..40 {
app.push_convo(ConvoBlock::Assistant(format!("reasoning line {index}")));
}
// The composer is the last panel on screen, so its top border is the last one drawn.
let composer_row =
|frame: &str| frame.lines().collect::<Vec<_>>().iter().rposition(|row| row.contains('╭'));
let idle = buffer_to_string(&render_app(&mut app, &backend));
assert!(idle.contains("reasoning line 39"), "the tail is on screen to begin with: {idle}");
let composer = composer_row(&idle).expect("a composer");
let asked = ask(
&mut app,
luxe_core::event::Event::QuestionAsked {
id: luxe_core::question::QuestionRequestId::new(),
session_id: "session-a".into(),
prompt: "Which runtime should the worker use?".into(),
options: vec!["tokio".into(), "async-std".into()],
multi: false,
},
);
assert!(asked.contains("Which runtime"), "the question is up: {asked}");
assert!(asked.contains("reasoning line 39"), "and so is what prompted it: {asked}");
let approved = ask(
&mut app,
luxe_core::event::Event::PermissionRequested {
id: luxe_core::permission::PermissionRequestId::new(),
session_id: "session-a".into(),
tool: "bash".into(),
permission: "bash".into(),
summary: "Run: rm -rf build".into(),
always_patterns: Vec::new(),
},
);
assert!(approved.contains("Permission required"), "the ask is up: {approved}");
assert!(approved.contains("reasoning line 39"), "and so is what prompted it: {approved}");
// The rows come out of the conversation, never out of the prompt the reader types into.
for frame in [&asked, &approved] {
assert_eq!(composer_row(frame), Some(composer), "the composer moved: {frame}");
}
// A terminal with no rows to spare keeps the prompt whole and the composer intact — the
// conversation can only stand down from rows it has.
let cramped = buffer_to_string(&render_app(&mut app, &test_backend(60, 12)));
assert!(cramped.contains("Allow once"), "the prompt is not squeezed: {cramped}");
let rows: Vec<&str> = cramped.lines().collect();
let top = composer_row(&cramped).expect("a composer");
assert!(rows[top + 2].contains('╰'), "the composer kept its rows: {cramped}");
}
/// Scrolled away from the bottom there is no animation to see, so nothing is held back — and coming
/// back to the bottom shows the whole message rather than a stale prefix of it.
#[test]
fn scrolling_away_from_the_bottom_stops_holding_text_back() {
let backend = test_backend(60, 10);
let mut app = create_app();
// Enough transcript to have somewhere to scroll.
for index in 0..8 {
app.push_convo(ConvoBlock::User {
text: format!("earlier {index}"),
attached: Vec::new(),
chips: Vec::new(),
});
}
let base = std::time::Instant::now();
app.status.frame_clock = Some(base);
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta { block: 0, delta: LUMP.into() }));
let _ = render_app(&mut app, &backend);
app.scroll_state.up_by(3);
assert!(!app.scroll_state.follow, "scrolling up leaves the bottom");
let _ = render_app(&mut app, &backend);
assert!(!app.reveal.pending(), "nothing is held back while the tail is off screen");
app.scroll_state.to_bottom();
let back = buffer_to_string(&render_app(&mut app, &backend));
assert_eq!(
revealed_count(&back, LUMP),
LUMP.chars().filter(|c| !c.is_whitespace()).count(),
"coming back to the bottom shows the whole message: {back}"
);
}
/// Where `needle` starts in the rendered buffer, as `(x, y)`.
pub(super) fn find_in_buffer(buffer: &Buffer, needle: &str) -> Option<(u16, u16)> {
(0..buffer.area.height).find_map(|y| {
let row: String = (0..buffer.area.width).map(|x| buffer[(x, y)].symbol()).collect();
row.find(needle).map(|byte| (row[..byte].chars().count() as u16, y))
})
}
/// The bug: a stream that goes quiet without closing left its last word painted on the canvas.
///
/// The trail that fades in behind the reveal cursor says "these characters are still arriving".
/// When the frontier catches up and nothing follows — a model pausing mid-answer, a block waiting
/// on the one after it, a provider that stops before it closes — the claim stops being true and the
/// newest characters are simply text the reader cannot see. Measured here the way a reader meets
/// it: the foreground the terminal is actually told to paint.
#[test]
fn a_stalled_stream_resolves_its_last_characters() {
let backend = test_backend(110, 20);
let mut app = create_app();
let base = std::time::Instant::now();
app.status.frame_clock = Some(base);
let total = LUMP.chars().filter(|c| !c.is_whitespace()).count();
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta { block: 0, delta: LUMP.into() }));
// Pace it out to the end of the lump. Nothing closes the stream, so the item stays growing.
let mut at = 0u32;
for _ in 0..400 {
let painted = advance_frames(&mut app, &backend, base, &mut at, 1);
if revealed_count(&painted, LUMP) == total {
break;
}
}
let buffer = render_app(&mut app, &backend);
let (head_x, head_y) = find_in_buffer(&buffer, "alpha").expect("the settled start is drawn");
let (tail_x, tail_y) = find_in_buffer(&buffer, "omega").expect("the newest word is drawn");
let tail = (tail_x + 4, tail_y);
let settled_fg = buffer[(head_x, head_y)].fg;
assert_ne!(
buffer[tail].fg, settled_fg,
"precondition: the character that just landed is still fading in"
);
// Nothing more arrives. The tail has to become readable, and on its own.
let budget = 40;
advance_frames(&mut app, &backend, base, &mut at, budget);
let buffer = render_app(&mut app, &backend);
assert_eq!(
buffer[tail].fg, settled_fg,
"the last character of a stalled stream is still painted on the background"
);
assert!(
!app.reveal.pending(),
"and the reveal clock stops rather than spinning on a still frame"
);
}
/// A still screen must be still. The image viewer draws over a transcript that also draws the same
/// image, and asking the store for one image at two sizes made every frame release and re-transmit
/// it — which shows up as the picture flickering while nothing is happening.
#[test]
fn the_open_image_viewer_does_not_re_transmit_on_every_frame() {
let backend = test_backend(100, 32);
let mut app = app_with_image(luxe_tui::graphics::ImageTier::Pixels);
let key = app.newest_visible_image().expect("the transcript has an image");
app.update(Msg::OpenImageViewer(key));
render_app(&mut app, &backend);
assert!(!app.images.drain_control().is_empty(), "the first frame transmits it");
for frame in 0..4 {
let buffer = render_app(&mut app, &backend);
assert!(
app.images.drain_control().is_empty(),
"frame {frame} re-transmitted the image the viewer is already showing"
);
assert!(
buffer.content.iter().any(|cell| cell.symbol().starts_with('\u{10EEEE}')),
"and it is still on screen"
);
}
}
/// Closing the viewer puts the transcript's own copy back, at the transcript's size.
#[test]
fn closing_the_viewer_returns_the_transcript_to_its_own_size() {
let backend = test_backend(100, 32);
let mut app = app_with_image(luxe_tui::graphics::ImageTier::Pixels);
let key = app.newest_visible_image().expect("an image");
render_app(&mut app, &backend);
let inline = app.images.fit(&key, 60, 12).expect("a transcript fit");
app.update(Msg::OpenImageViewer(key.clone()));
render_app(&mut app, &backend);
app.images.drain_control();
app.update(Msg::CloseImageViewer);
assert!(app.overlays.image_viewer.is_none());
let buffer = render_app(&mut app, &backend);
assert!(
buffer.content.iter().any(|cell| cell.symbol().starts_with('\u{10EEEE}')),
"the transcript draws it again"
);
assert!(inline.rows >= 1, "and the transcript's own size is still a real one");
}
/// Which image rows the buffer is currently showing, in screen order.
///
/// A kitty placeholder addresses itself, so the buffer says exactly which row of the image each
/// cell is displaying — which is what makes the clipping checkable rather than a matter of opinion.
pub(super) fn painted_image_rows(buffer: &Buffer) -> Vec<u16> {
let width = buffer.area.width as usize;
buffer
.content
.chunks(width)
.filter_map(|row| {
let symbol = row
.iter()
.map(|cell| cell.symbol())
.find(|symbol| symbol.starts_with('\u{10EEEE}'))?;
// Second char is the row diacritic; its index in the protocol's alphabet is the row.
let diacritic = symbol.chars().nth(1)?;
u16::try_from(ROW_DIACRITICS.iter().position(|mark| *mark == diacritic)?).ok()
})
.collect()
}
/// The first few entries of the protocol's coordinate alphabet — enough for any capped image.
pub(super) const ROW_DIACRITICS: [char; 24] = [
'\u{305}', '\u{30D}', '\u{30E}', '\u{310}', '\u{312}', '\u{33D}', '\u{33E}', '\u{33F}',
'\u{346}', '\u{34A}', '\u{34B}', '\u{34C}', '\u{350}', '\u{351}', '\u{352}', '\u{357}',
'\u{35B}', '\u{363}', '\u{364}', '\u{365}', '\u{366}', '\u{367}', '\u{368}', '\u{369}',
];
/// Scrolling a picture through a viewport made of text is the case the whole placement design
/// exists for. Only the visible rows are painted, they are the *right* rows, and when the image
/// leaves the viewport nothing of it is left behind — the ghost image that every cursor-positioned
/// approach has to clean up by hand, and that this one cannot produce.
#[test]
fn an_image_scrolls_through_the_viewport_without_leaving_anything_behind() {
let backend = test_backend(100, 18);
let mut app = app_with_image(luxe_tui::graphics::ImageTier::Pixels);
for index in 0..40 {
app.push_convo(ConvoBlock::Assistant(format!("line of prose number {index}")));
}
app.update(Msg::TerminalResized { width: 100, height: 18 });
// Walk the transcript from the top, one line at a time, and watch the image go by.
app.scroll_state.follow = false;
let mut seen_partial_top = false;
let mut seen_whole = false;
let mut fit_rows = 0;
for offset in 0..30 {
app.scroll_state.offset = offset;
let buffer = render_app(&mut app, &backend);
let rows = painted_image_rows(&buffer);
if rows.is_empty() {
continue;
}
// Whatever is on screen is a contiguous run of the image's rows, in order.
assert!(
rows.windows(2).all(|pair| pair[1] == pair[0] + 1),
"image rows on screen are contiguous and in order, got {rows:?}"
);
fit_rows = fit_rows.max(rows.last().copied().unwrap_or(0) + 1);
if *rows.first().expect("non-empty") > 0 {
seen_partial_top = true;
}
if rows.len() > 1 && rows.first() == Some(&0) {
seen_whole = true;
}
}
// And with the transcript scrolled well past it, not one cell of it survives. The image sits
// at the top of this transcript, so "past it" is a large offset.
app.scroll_state.offset = 40;
let buffer = render_app(&mut app, &backend);
let left_behind = painted_image_rows(&buffer);
assert!(fit_rows > 1, "the image occupied several rows: {fit_rows}");
assert!(seen_whole, "it was fully visible at some point");
assert!(seen_partial_top, "and clipped at the top of the viewport at another");
assert!(
left_behind.is_empty(),
"scrolled away entirely, no placeholder cell is left behind — the ghost image this \
placement design exists to make impossible; found {left_behind:?}"
);
}
/// The tool the reader never asked to watch. `activate_tools` loads a deferred tool's schema — a
/// fact about Luxe's request budget, not a step in anyone's task — and it lands directly in front
/// of the tool that actually did something. A successful one leaves no card; a failed one does,
/// because a call nobody can see cannot explain the stall it caused.
#[test]
fn a_successful_schema_load_leaves_no_card_but_a_failed_one_does() {
let backend = test_backend(100, 24);
let mut app = create_app();
app.update(Msg::Engine(luxe_core::Event::SessionLoaded {
session_id: "session-a".into(),
messages: vec![],
}));
let activity = |call: &str, name: &str, state, revision| {
let mut activity = luxe_core::ToolActivity::running("session-a", call, name, name, 1);
activity.state = state;
activity.revision = revision;
luxe_core::Event::ToolActivityUpdated(Box::new(activity))
};
app.update(Msg::Engine(activity("c1", "activate_tools", ToolActivityState::Running, 0)));
app.update(Msg::Engine(activity("c1", "activate_tools", ToolActivityState::Succeeded, 1)));
app.update(Msg::Engine(activity("c2", "screenshot", ToolActivityState::Succeeded, 1)));
let rendered = rows_of(&render_app(&mut app, &backend)).join("\n");
assert!(rendered.contains("screenshot"), "the tool that did something is on screen");
assert!(
!rendered.contains("activate_tools"),
"the schema load that went fine is not: {rendered}"
);
// The state is still recorded, so nothing downstream lost track of the call.
assert!(app.tool_activity.contains_key(&("session-a".into(), "c1".into())));
// One that failed has to be visible — the model is about to do something inexplicable.
app.update(Msg::Engine(activity("c3", "activate_tools", ToolActivityState::Failed, 1)));
let rendered = rows_of(&render_app(&mut app, &backend)).join("\n");
assert!(rendered.contains("activate_tools"), "a failed schema load explains itself");
}
/// Rows of the transcript that carry anything, as a crude "how much is on screen" measure.
pub(super) fn occupied_rows(buffer: &Buffer) -> usize {
rows_of(buffer).iter().filter(|row| !row.trim().is_empty()).count()
}
/// A turn only ever adds. Content that appears and then vanishes reads as a glitch even when the
/// end state is right, and the transcript has several ways to do it by accident: the staggered
/// reveal, a card gaining its body, and — since images — a card growing by the height of a picture
/// the moment the pixels land. This drives the exact event order of a `screenshot` turn and asserts
/// the transcript never shrinks between frames.
#[test]
fn a_streaming_turn_never_takes_content_back() {
use luxe_core::message::{ContentBlock, Message, Role, ToolOutput};
let backend = test_backend(100, 40);
let mut app = create_app();
app.images = pinned_store(luxe_tui::graphics::ImageTier::Pixels);
app.update(Msg::Engine(luxe_core::Event::SessionLoaded {
session_id: "s".into(),
messages: vec![],
}));
// The reveal is what stages content in; pace it off so this measures structure, not animation.
app.reveal_catch_up();
let mut frames: Vec<(&str, usize)> = Vec::new();
let mut observe = |app: &mut App, label: &'static str| {
app.reveal_catch_up();
frames.push((label, occupied_rows(&render_app(app, &backend))));
};
app.push_convo(ConvoBlock::User {
text: "how does the page look?".into(),
attached: vec![],
chips: Vec::new(),
});
observe(&mut app, "user message");
app.update(Msg::Engine(luxe_core::Event::ThinkingDelta {
block: 0,
delta: "Checking whether the screenshot tool is loaded.".into(),
}));
observe(&mut app, "reasoning");
let call = luxe_core::ToolActivity::running("s", "c1", "screenshot", "url · e.com", 1);
app.update(Msg::Engine(luxe_core::Event::ToolActivityUpdated(Box::new(call.clone()))));
observe(&mut app, "tool started");
// The result commits first (this is where the pixels arrive), then the activity goes terminal.
app.update(Msg::Engine(luxe_core::Event::MessageCommitted {
session_id: "s".into(),
entry_id: luxe_core::session::EntryId("e1".into()),
message: Message {
role: Role::Tool,
content: vec![ContentBlock::ToolResult {
call_id: "c1".into(),
content: vec![
ToolOutput::Text("Captured url (320x160).".into()),
ToolOutput::Image {
data: split_png(320, 160),
mime: "image/png".into(),
name: None,
},
],
is_error: false,
}],
},
}));
observe(&mut app, "image arrived");
let mut done = call;
done.revision = 1;
done.state = ToolActivityState::Succeeded;
done.elapsed_ms = Some(362);
app.update(Msg::Engine(luxe_core::Event::ToolActivityUpdated(Box::new(done))));
observe(&mut app, "tool finished");
app.update(Msg::Engine(luxe_core::Event::TokenDelta {
block: 1,
delta: "A sparse white page with a centered heading.".into(),
}));
observe(&mut app, "answer");
for pair in frames.windows(2) {
let ((before, was), (after, now)) = (pair[0], pair[1]);
assert!(
now >= was,
"the transcript shrank going from {before} ({was} rows) to {after} ({now} rows) — \
content that appears and then vanishes reads as a glitch"
);
}
assert!(frames.last().expect("frames").1 > frames[0].1, "and it grew overall: {frames:?}");
}

View File

@@ -0,0 +1,344 @@
//! Review context — the backdrop, the rail and the guide's head.
use super::*;
/// A modal overlay dims the review behind it, but a blanket `set_style(dim)` patched every cell's
/// foreground — and nearly every bundled theme maps `selectedBg` to the same color as `dim`, so the
/// selected file row and diff line rendered as unreadable solid blocks. Highlighted cells must step
/// up to `muted` instead.
#[test]
fn modal_backdrop_keeps_highlighted_review_rows_readable() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let selected_bg = app.theme_styles.selected_bg.bg.expect("selection background");
let dim = app.theme_styles.dim.fg.expect("dim foreground");
let muted = app.theme_styles.muted.fg.expect("muted foreground");
assert_eq!(dim, selected_bg, "nord maps selectedBg onto dim — the case this guards");
let before = render_app(&mut app, &backend);
let highlighted: Vec<(u16, u16)> = (0..height)
.flat_map(|y| (0..width).map(move |x| (x, y)))
.filter(|&(x, y)| before[(x, y)].bg == selected_bg)
.collect();
assert!(!highlighted.is_empty(), "the fixture renders a selected row");
app.update(Msg::GuidedReviewToggleHelp);
let after = render_app(&mut app, &backend);
for (x, y) in highlighted {
// Overlay cells legitimately repaint; only the backdrop behind it is under test.
if after[(x, y)].bg != selected_bg {
continue;
}
assert_ne!(
after[(x, y)].fg,
selected_bg,
"cell ({x},{y}) became invisible dim-on-dim behind the overlay"
);
assert_eq!(after[(x, y)].fg, muted, "highlighted backdrop cells step up to muted");
}
}
/// The review carries no wait, because it does not open until there is nothing left to wait for.
///
/// Every heading, sentence and per-file note here arrives with the guide pass, which takes tens of
/// seconds on a local model. This surface used to open on a structural placeholder and rewrite
/// itself under the reader — first silently, then behind a spinner that only advanced if something
/// happened to tick. Both were answers to the wrong question: the reader should not be on this
/// screen yet. The waiting is announced in the tray above the composer, where they are.
#[test]
fn the_review_surface_never_shows_a_wait_and_the_tray_does() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let shown = buffer_to_string(&render_app(&mut app, &backend));
assert!(!shown.contains("writing the guide"), "no wait on the review: {shown}");
// And in the conversation, a review being prepared says so where it can be read.
let mut chat = seeded_app("nord", FixtureScenario::ChatIdle).unwrap();
chat.update(Msg::TerminalResized { width, height });
chat.review.queued = Some(luxe_tui::app::QueuedReview {
target: luxe_core::guided_review::ReviewTarget::WorkingTree,
state: luxe_tui::app::QueuedReviewState::Capturing,
});
let waiting = buffer_to_string(&render_app(&mut chat, &backend));
assert!(waiting.contains("capturing"), "the tray carries the wait: {waiting}");
chat.review.queued.as_mut().expect("queued").state = luxe_tui::app::QueuedReviewState::Ready;
let ready = buffer_to_string(&render_app(&mut chat, &backend));
assert!(ready.contains("review ready"), "and then offers: {ready}");
}
/// A review opens on deterministic chapters and upgrades in place, so the rail must say which it
/// is showing — a structural placeholder read as the agent's explanation is worse than no prose.
#[test]
fn the_rail_names_how_the_visible_chapters_were_produced() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let review = app.guided_review.clone().expect("fixture review");
app.update(Msg::Engine(luxe_core::event::Event::GuidedReviewGuideUpdated {
request_id: luxe_core::guided_review::ReviewLoadRequestId::new(),
review_id: review.id.clone(),
revision_id: review.revision_id.clone(),
chapters: review.chapters.clone(),
provenance: luxe_core::guided_review::GuideProvenance::Model { batches: 1 },
brief: None,
}));
let model_written = buffer_to_string(&render_app(&mut app, &backend));
assert!(!model_written.contains("structural guide"), "the model wrote these chapters");
app.update(Msg::Engine(luxe_core::event::Event::GuidedReviewGuideUpdated {
request_id: luxe_core::guided_review::ReviewLoadRequestId::new(),
review_id: review.id.clone(),
revision_id: review.revision_id,
chapters: review.chapters,
provenance: luxe_core::guided_review::GuideProvenance::Structural { reason: None },
brief: None,
}));
let structural = buffer_to_string(&render_app(&mut app, &backend));
assert!(structural.contains("structural guide"), "fallback says so: {structural}");
}
/// A Guide computed for a revision the reviewer has moved past must never replace what is on
/// screen — the prose would describe a different diff.
#[test]
fn a_guide_for_another_revision_is_discarded() {
let (width, height) = (160, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let review = app.guided_review.clone().expect("fixture review");
let original = review.chapters[0].title.clone();
let mut replacement = review.chapters.clone();
replacement[0].title = "Chapters from a stale revision".into();
app.update(Msg::Engine(luxe_core::event::Event::GuidedReviewGuideUpdated {
request_id: luxe_core::guided_review::ReviewLoadRequestId::new(),
review_id: review.id,
revision_id: luxe_core::guided_review::ReviewRevisionId::from_canonical_bytes(b"other"),
chapters: replacement,
provenance: luxe_core::guided_review::GuideProvenance::Model { batches: 1 },
brief: None,
}));
let after = app.guided_review.as_ref().expect("review");
assert_eq!(after.chapters[0].title, original);
// The prose on screen is still the review's own, not the one written for a diff the
// reader is no longer looking at.
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains(&original), "{rendered}");
assert!(!rendered.contains("Chapters from a stale revision"), "{rendered}");
}
/// The guide is the landing surface: intent, what the change does, and the contents — read before
/// the diff, so attention goes to judgement rather than reconstruction.
#[test]
fn the_guide_leads_with_intent_and_the_contents() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewBrief).unwrap();
app.update(Msg::TerminalResized { width, height });
let content = buffer_to_string(&render_app(&mut app, &backend));
// The summary is written for a reviewer, not replayed from the conversation they just left.
assert!(
content.contains("unrepresentable"),
"the model's account of what the change does: {content}"
);
assert!(content.contains("Shared notification model"), "and the contents: {content}");
// Headings are gone with the sections they labeled: the intent is the first thing in the pane,
// so nothing has to announce it.
for gone in ["Why this change", "What it does", "The walkthrough"] {
assert!(!content.contains(gone), "{gone:?} is a heading over nothing now: {content}");
}
// The shell history is not a verdict: a grep that matched nothing is not a failed check.
assert!(!content.contains("How it was verified"), "the synthesized list is gone: {content}");
assert!(!content.contains("Checks failed"), "and so is the verdict it fed: {content}");
// Coverage gaps go to the agent and to the file being read, never to a ranked list: a missing
// test is work to hand off, not a call for the reviewer's judgement.
assert!(
!content.contains("has no covering test"),
"coverage gaps are not ranked call-outs: {content}"
);
// One word for the unit of reading. The guide counts "Chapters", the footer moves by
// "chapter", the diff ends "end of chapter".
assert!(!content.contains("section"), "a chapter is never called a section: {content}");
assert!(!content.contains("walked"), "progress is stated as reviewed: {content}");
}
/// A review is captured from the project's worktree, so files changed anywhere else are absent
/// from it and no amount of reading the diff will reveal them. The rail has to say so.
#[test]
fn the_review_says_when_the_session_worked_outside_the_project() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewBrief).unwrap();
app.update(Msg::TerminalResized { width, height });
let mut workspace = empty_workspace("luxe");
workspace.external = luxe_core::ExternalChangesSummary {
roots: vec![luxe_core::ExternalRootSummary {
root: "/home/dev/work/sdk".into(),
display_path: "~/work/sdk".into(),
git_branch: Some("main".into()),
git: true,
files: Vec::new(),
total_files: 2,
truncated: false,
}],
total_files: 2,
additions: Some(9),
deletions: Some(1),
truncated: false,
};
app.workspace = Some(workspace);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
content.contains("2 files changed elsewhere"),
"the review names the work it cannot cover: {content}"
);
// And says nothing at all when there is nothing to say, which is what makes the line above
// worth reading when it appears.
app.workspace.as_mut().expect("seeded above").external =
luxe_core::ExternalChangesSummary::default();
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(!content.contains("changed elsewhere"), "nothing outside, nothing claimed: {content}");
}
/// Without a model-written brief the guide still says what it knows — and says whose words those
/// are, so a raw transcript is never mistaken for a summary.
#[test]
fn a_guide_with_no_model_summary_falls_back_to_the_record_and_labels_it() {
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewBrief).unwrap();
app.update(Msg::TerminalResized { width, height });
let written = buffer_to_string(&render_app(&mut app, &backend));
assert!(
!written.contains("no summary was written"),
"a real summary is not labeled as a stand-in: {written}"
);
app.guided_review.as_mut().expect("a review").brief = None;
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
content.contains("no summary was written"),
"labeled, so the record does not pass as a summary: {content}"
);
}
/// Side-by-side is a view of the unified row space, not a second one: it shows the whole file, keeps
/// the columns on fixed screen positions, and pairs each removal with its replacement.
#[test]
fn side_by_side_shows_the_file_with_aligned_columns_and_word_emphasis() {
let (width, height) = (180, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewWide).unwrap();
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
// The old renderer showed exactly one hunk; the fixture file has two.
assert!(content.contains("@@ -4,3 +4,4 @@"), "first hunk: {content}");
assert!(content.contains("@@ -18,1 +18,2 @@"), "second hunk in the same view: {content}");
// The removal and its replacement share a row: old text left, new text right.
let row = (0..height)
.find(|&y| {
let text = row_text(&buffer, y, width);
text.contains("pub category: String,") && text.contains("NotificationCategory")
})
.expect("the replaced line renders as one paired row");
// The column rule sits at the same screen column on every rendered row, which is what the old
// renderer got wrong (an unpadded context cell moved it).
let divider = (0..width)
.find(|&x| buffer[(x, row)].symbol() == "│")
.expect("a column rule on the paired row");
let rows_with_content: Vec<u16> =
(0..height).filter(|&y| row_text(&buffer, y, width).contains("pub ")).collect();
assert!(rows_with_content.len() >= 3, "several source rows render");
for y in rows_with_content {
assert_eq!(
buffer[(divider, y)].symbol(),
"│",
"the rule holds its column on row {y}: {content}"
);
}
// Word-level emphasis on both sides: pairing is exact here, so the changed span is too — bold in
// both columns, and never struck through.
let marked_with = |needle: &str, modifier: ratatui::style::Modifier| {
let (y, column) = (0..height)
.find_map(|y| {
let text = row_text(&buffer, y, width);
text.find(needle).map(|byte| (y, text[..byte].chars().count() as u16))
})
.unwrap_or_else(|| panic!("{needle} renders somewhere"));
buffer[(column, y)].modifier.contains(modifier)
};
assert!(
marked_with("String,", ratatui::style::Modifier::BOLD),
"the removed type is bold: {content}"
);
assert!(
!marked_with("String,", ratatui::style::Modifier::CROSSED_OUT),
"and readable: {content}"
);
assert!(
marked_with("NotificationCategory", ratatui::style::Modifier::BOLD),
"the added type is bold: {content}"
);
}
/// Soft-wrap works in side-by-side too: a long line stays fully visible, the two columns stay
/// vertically aligned, and one logical row keeps one click target across every visual line it spans.
#[test]
fn side_by_side_soft_wraps_long_lines_without_losing_column_alignment() {
let (width, height) = (200, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewWide).unwrap();
// A replaced line far longer than either column can show.
{
let file = &mut app.guided_review.as_mut().unwrap().files[0];
let long_old = format!(" pub category: String, // {}", "old ".repeat(40));
let long_new = format!(" pub category: NotificationCategory, // {}", "new ".repeat(40));
for line in &mut file.hunks[0].lines {
match line.kind {
ReviewLineKind::Deletion => line.text = long_old.clone(),
ReviewLineKind::Addition => line.text = long_new.clone(),
_ => {}
}
}
}
app.update(Msg::TerminalResized { width, height });
app.update(Msg::DispatchUiAction(luxe_core::keymap::UiAction::ReviewToggleWordWrap));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
// The tail of both sides is on screen rather than clipped off the right edge.
assert!(content.contains("new new"), "the added line wrapped into view: {content}");
assert!(content.contains("old old"), "the removed line wrapped into view: {content}");
// Continuation rows are marked, as they are unified.
assert!(content.contains('↳'), "wrapped rows carry a continuation glyph: {content}");
// The rule holds one screen column across every wrapped row. Scanned inside the content pane
// only: the rail divider and the mode tabs draw their own vertical rules.
let pane = luxe_tui::workspace_layout::LEFT_RAIL_WIDTH
+ luxe_tui::workspace_layout::CONTEXT_DOCK_SEPARATOR_WIDTH;
let columns: std::collections::HashSet<u16> = (0..height)
.filter_map(|y| (pane..width).find(|&x| buffer[(x, y)].symbol() == "│"))
.collect();
assert_eq!(columns.len(), 1, "the rule never wanders: {columns:?}");
}

View File

@@ -0,0 +1,430 @@
//! Review guide — the guide pane's rows, the noise fixtures and the review source picker.
use super::*;
/// Guide file-row clicks (plan B6): after a render publishes each file row's wrapped-Y region,
/// clicking a guide file row selects that file.
#[test]
fn clicking_a_guide_file_row_selects_that_file() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (140, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let expected = app.guided_review.as_ref().unwrap().files[0].id.clone();
let buffer = render_app(&mut app, &backend);
// Search only the left rail (its file row) — the content pane's sticky breadcrumb also names
// the file, so scanning the full row width would match that instead.
let row = (0..height)
.find(|&y| row_text(&buffer, y, 40).contains("src/notification.rs"))
.expect("the guide file row renders");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 10, // inside the guide rail
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => assert!(
matches!(*message, Msg::GuidedReviewSelectFile(ref id) if id == &expected),
"clicking the file row selects that file"
),
other => panic!("expected a select-file message from the click, got {other:?}"),
}
}
/// Clicking a chapter row in the guide points the review at that chapter.
#[test]
fn clicking_a_guide_chapter_row_opens_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (160, 44);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewDemo).unwrap();
app.update(Msg::TerminalResized { width, height });
render_app(&mut app, &backend);
let (rect, chapter_id) = app
.hit
.borrow()
.clicks()
.find_map(|(rect, target)| match target {
luxe_tui::mouse::MouseTarget::ReviewGuideChapter(id) => Some((rect, id.clone())),
_ => None,
})
.expect("the guide publishes its chapter rows");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: rect.x + 1,
row: rect.y,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => match *message {
Msg::GuidedReviewOpenChapter(id) => assert_eq!(id, chapter_id),
other => panic!("expected the chapter under the pointer, got {other:?}"),
},
other => panic!("expected a chapter to open, got {other:?}"),
}
}
/// Clicking a guide file row opens exactly that file.
#[test]
fn clicking_a_guide_file_row_reads_what_it_points_at() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (140, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &backend);
let guide = luxe_tui::workspace_layout::guide_pane_width(width);
let row = (0..height)
.find(|&y| {
let text: String =
(0..guide).map(|x| buffer[(x, y)].symbol()).collect::<Vec<_>>().join("");
text.contains("M src/notification.rs")
})
.expect("the file row renders under its chapter");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 10,
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::Msg(message) => {
assert!(matches!(*message, Msg::GuidedReviewSelectFile(_)));
app.update(*message);
}
other => panic!("expected the file row to open, got {other:?}"),
}
// The detail pane follows the guide's selection with no second step.
let after = buffer_to_string(&render_app(&mut app, &backend));
assert!(after.contains("src/notification.rs"), "the file is on screen: {after}");
assert!(after.contains("@@"), "and its diff beside the guide: {after}");
}
/// The guide is the contents page: every chapter, and the files under it, with the evidence that
/// accounts for them. Hunk rows appear under the file being read and nowhere else.
#[test]
fn the_guide_lists_every_chapter_and_file_with_its_evidence() {
let (width, height) = (140, 30);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
app.update(Msg::TerminalResized { width, height });
let guide = luxe_tui::workspace_layout::guide_pane_width(width);
let buffer = render_app(&mut app, &backend);
let content: String =
(0..height).map(|y| row_text(&buffer, y, guide)).collect::<Vec<_>>().join("\n");
assert!(content.contains("01 / 01"), "the chapter, numbered: {content}");
assert!(content.contains("Shared notification model"), "and titled: {content}");
assert!(content.contains("M src/notification.rs"), "its file, with status: {content}");
assert!(content.contains("+3 \u{2212}2"), "with real counts, not a \u{b1}: {content}");
}
#[test]
fn guided_review_help_overlay_is_local_and_names_review_controls() {
let (width, height) = (100, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
app.update(Msg::GuidedReviewToggleHelp);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("Help · Guided Review"), "missing help title: {content}");
// Grouped, complete help (plan A4): every verb group is present, including the feedback and
// finish keys the old help omitted.
for expected in [
"Move",
"Read",
"Feedback",
"Session",
"next stop; past the last, finish",
"open collapsed churn",
"ask; the agent answers",
"comment, for the agent to act on",
"all comments: send, reply, verify",
"resolve or verify",
"show or hide the guide",
"ctrl+r",
"alt+enter",
"back to chat",
"? close",
] {
assert!(content.contains(expected), "help missing {expected:?}: {content}");
}
}
#[test]
fn guided_review_noise_fixture_collapses_and_expands_formatting_hunks() {
let (width, height) = (140, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
app.update(Msg::TerminalResized { width, height });
let collapsed = buffer_to_string(&render_app(&mut app, &backend));
// The folded run says what it is on its own row in the diff, so the guide does not repeat it
assert!(
collapsed.contains("1 change · 2 lines ·") && collapsed.contains("enter opens"),
"missing the fold row: {collapsed}"
);
assert!(!collapsed.contains("mechanical change collapsed"), "a banner too: {collapsed}");
assert!(!collapsed.contains("f opens them"), "and its hint: {collapsed}");
assert!(!collapsed.contains("@@ -1,1 +1,1 @@ imports"), "folded hunk rendered: {collapsed}");
app.update(Msg::GuidedReviewToggleNoiseDetails);
let details = buffer_to_string(&render_app(&mut app, &backend));
// The explanation names *why this hunk* was folded, not a generic blurb about the classifier.
assert!(
details.contains("1 whitespace-only, tokens identical"),
"missing per-class fold reason: {details}"
);
assert!(
details.contains("Semantic and comment-only changes stay"),
"missing the visibility promise: {details}"
);
assert!(details.contains("1 mechanical change collapsed · 2 lines"), "{details}");
app.update(Msg::GuidedReviewToggleNoise);
let expanded = buffer_to_string(&render_app(&mut app, &backend));
assert!(expanded.contains("@@ -1,1 +1,1 @@ imports"), "expanded hunk missing: {expanded}");
assert!(!expanded.contains("collapsed · 2 lines"), "stale fold summary: {expanded}");
}
#[test]
fn guided_review_noise_summary_survives_medium_and_narrow_layouts() {
for (width, expected) in
[(100, "1 mechanical change collapsed · 2 lines · f opens them"), (80, "1 collapsed")]
{
let height = 24;
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
app.update(Msg::TerminalResized { width, height });
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains(expected), "missing {expected:?}: {content}");
}
}
#[test]
fn guided_review_medium_context_explains_noise_classification() {
let (width, height) = (100, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
app.update(Msg::TerminalResized { width, height });
let collapsed = buffer_to_string(&render_app(&mut app, &backend));
assert!(
collapsed.contains("1 mechanical change collapsed · 2 lines · f opens them"),
"missing folded summary: {collapsed}"
);
app.update(Msg::GuidedReviewToggleNoiseDetails);
let expanded = buffer_to_string(&render_app(&mut app, &backend));
assert!(
expanded.contains("1/2 folded: format/generated/lockfile/mechanical;")
&& expanded.contains("semantic/comments kept · d close"),
"missing medium classification detail: {expanded}"
);
}
#[test]
fn guided_review_narrow_context_discloses_noise_classification() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewNoise).unwrap();
app.update(Msg::TerminalResized { width, height });
app.update(Msg::GuidedReviewToggleNoiseDetails);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
content.contains("1 fmt/gen/lock/mech"),
"missing narrow classification disclosure: {content}"
);
}
#[test]
fn guided_review_narrow_fixture_keeps_chapter_and_file_orientation() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
content.contains("01/01 · Shared notification model · src/notification.rs"),
"missing narrow chapter/file header: {content}"
);
assert!(
content.contains("@@ -4,3 +4,4 @@ pub struct Notification"),
"missing narrow diff: {content}"
);
}
#[test]
fn guided_review_tiny_fixture_explains_the_minimum_size() {
let (width, height) = (30, 5);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
content.contains("Review needs 40 × 5 cells"),
"missing minimum-size message: {content}"
);
assert!(content.contains("esc back to chat"), "missing return guidance: {content}");
assert!(!content.contains("@@ -4,3"), "tiny terminal rendered a partial diff: {content}");
}
#[test]
fn guided_review_source_picker_enter_dispatches_the_selected_source() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::GuidedReview;
app.update(Msg::GuidedReviewToggleSourcePicker);
assert!(matches!(
claim(&mut app, &key(KeyCode::Enter)),
Some(Msg::GuidedReviewSelectSourcePicker)
));
}
#[test]
fn guided_review_source_reference_routes_plain_text_before_review_keys() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::GuidedReview;
app.update(Msg::GuidedReviewToggleSourcePicker);
app.update(Msg::GuidedReviewSourcePickerNext);
app.update(Msg::GuidedReviewSelectSourcePicker);
assert!(matches!(
claim(&mut app, &key(KeyCode::Char('f'))),
Some(Msg::GuidedReviewSourceReferenceInsert('f'))
));
assert!(matches!(
claim(&mut app, &key(KeyCode::Backspace)),
Some(Msg::GuidedReviewSourceReferenceBackspace)
));
assert!(matches!(
claim(&mut app, &key(KeyCode::Esc)),
Some(Msg::GuidedReviewCancelSourceReference)
));
}
#[test]
fn guided_review_source_picker_names_targets_and_unavailable_last_turn() {
let (width, height) = (100, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
app.update(Msg::GuidedReviewToggleSourcePicker);
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("Change review source"), "missing source picker: {content}");
assert!(content.contains("› Working Tree"), "missing selected working tree: {content}");
assert!(content.contains("Last Turn"), "missing last-turn source: {content}");
assert!(
content.contains("unavailable — no completed turn"),
"missing disabled reason: {content}"
);
assert!(content.contains("Base"), "missing base source: {content}");
assert!(content.contains("Commit"), "missing commit source: {content}");
assert!(
content.contains("enter load · ↑/↓ choose · esc close"),
"missing source controls: {content}"
);
app.update(Msg::GuidedReviewSourcePickerNext);
app.update(Msg::GuidedReviewSelectSourcePicker);
let base_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
base_content.contains("Base reference: _"),
"missing Base reference entry: {base_content}"
);
app.update(Msg::GuidedReviewSourceReferenceInsert('m'));
app.update(Msg::GuidedReviewSourceReferenceInsert('a'));
app.update(Msg::GuidedReviewSourceReferenceInsert('i'));
app.update(Msg::GuidedReviewSourceReferenceBackspace);
let typed_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
typed_content.contains("Base reference: ma"),
"missing typed Base reference: {typed_content}"
);
app.update(Msg::GuidedReviewCancelSourceReference);
app.update(Msg::GuidedReviewSourcePickerNext);
app.update(Msg::GuidedReviewSelectSourcePicker);
let commit_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
commit_content.contains("Commit object ID: _"),
"missing Commit object ID entry: {commit_content}"
);
assert!(
commit_content.contains("enter load commit · esc back"),
"missing Commit entry controls: {commit_content}"
);
}
#[test]
fn guided_review_wide_fixture_renders_chapter_context_beside_the_diff() {
let (width, height) = (140, 24);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("01 / 01"), "missing chapter progress: {content}");
assert!(content.contains("Shared notification model"), "missing chapter title: {content}");
assert!(content.contains("M src/notification.rs"), "missing the file row: {content}");
assert!(
content.contains("pub struct Notification hunk 1 of 2"),
"the detail pane names what it is showing: {content}"
);
assert!(content.contains("@@ -4,3 +4,4 @@"), "missing adjacent diff: {content}");
// Both halves at once: the story and the code it describes, with no mode between them.
assert!(content.contains("Shared notification model") && content.contains("@@"));
app.update(Msg::GuidedReviewHunkNext);
let next_hunk_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
next_hunk_content.contains("› @@ -18,1 +18,2 @@ impl Notification"),
"next hunk did not become visibly selected: {next_hunk_content}"
);
assert!(
!next_hunk_content.contains("› @@ -4,3 +4,4 @@ pub struct Notification"),
"previous hunk retained selected marker: {next_hunk_content}"
);
app.update(Msg::GuidedReviewHunkPrevious);
let previous_hunk_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(
previous_hunk_content.contains("› @@ -4,3 +4,4 @@ pub struct Notification"),
"previous hunk did not restore the original marker: {previous_hunk_content}"
);
assert!(
!previous_hunk_content.contains("› @@ -18,1 +18,2 @@ impl Notification"),
"next hunk retained selected marker after moving back: {previous_hunk_content}"
);
// Progress is the step you are on — never a per-hunk tally, and never a second counter beside
// it counting something else.
let workload_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(workload_content.contains("Step "), "the rail says where you are: {workload_content}");
assert!(!workload_content.contains("to review"), "and only once: {workload_content}");
assert!(!workload_content.contains("Reviewed "), "no completion counter: {workload_content}");
assert!(workload_content.contains("space next"), "stepping is offered: {workload_content}");
// Walking to the end of a chapter records it as read — against the chapter itself, in the
// guide, rather than as a second tally in the foot.
app.update(Msg::GuidedReviewHunkNext);
app.update(Msg::GuidedReviewHunkNext);
let walked_content = buffer_to_string(&render_app(&mut app, &backend));
assert!(walked_content.contains("reviewed"), "the chapter is marked: {walked_content}");
assert!(!walked_content.contains("Chapters 1/1"), "and not counted twice: {walked_content}");
}

View File

@@ -0,0 +1,378 @@
//! Routing — keys and clicks reach the surface they belong to: dashboards, pickers and the review.
use super::*;
pub(super) fn key(code: KeyCode) -> KeyEvent {
KeyEvent::new(code, KeyModifiers::NONE)
}
/// Session-picker clicks (plan B4): clicking a session row resolves straight to SessionSelected
/// for the clicked row (not the default first row).
#[test]
fn clicking_a_session_picker_row_selects_that_session() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (120, 40);
let backend = test_backend(width, height);
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::TerminalResized { width, height });
app.overlays.session_picker = Some(SessionPickerState::new(vec![
SessionEntry {
id: "session-1".to_string(),
name: "First session".to_string(),
age: "just now".to_string(),
search_text: "first".to_string(),
preview: Vec::new(),
},
SessionEntry {
id: "session-2".to_string(),
name: "Second session".to_string(),
age: "1h ago".to_string(),
search_text: "second".to_string(),
preview: Vec::new(),
},
]));
app.current_view = ViewMode::SessionPicker;
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Second session"))
.expect("the second session row renders");
let click = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: width / 2,
row,
modifiers: KeyModifiers::NONE,
};
match route_mouse(&mut app, &click) {
RouteAction::SessionSelected(id) => assert_eq!(id, "session-2", "click selects that row"),
other => panic!("expected SessionSelected from the click, got {other:?}"),
}
}
/// Picker selection returns the session id, and the main-loop consumer emits LoadSession.
#[test]
fn test_session_picker_selection_emits_load_session() {
let (tx, mut rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
let entries = vec![
SessionEntry {
id: "session-1".to_string(),
name: "First session".to_string(),
age: "just now".to_string(),
search_text: "First session prompt".to_string(),
preview: Vec::new(),
},
SessionEntry {
id: "session-2".to_string(),
name: "Second session".to_string(),
age: "1h ago".to_string(),
search_text: "Second session prompt".to_string(),
preview: Vec::new(),
},
];
app.overlays.session_picker = Some(SessionPickerState::new(entries));
app.current_view = ViewMode::SessionPicker;
match route_key(&mut app, &key(KeyCode::Enter)) {
RouteAction::SessionSelected(id) => {
assert_eq!(id, "session-1");
// Mirror the consumer's side effect.
app.engine_tx.try_send(luxe_core::engine::Action::LoadSession(id)).unwrap();
}
other => panic!("expected SessionSelected, got {other:?}"),
}
match rx.try_recv() {
Ok(luxe_core::engine::Action::LoadSession(id)) => assert_eq!(id, "session-1"),
other => panic!("expected LoadSession action, got {other:?}"),
}
}
/// Chat (default) view passes keys straight through as Msg::Key.
#[test]
fn test_route_key_chat_passes_through() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::Chat;
let action = route_key(&mut app, &key(KeyCode::Char('a')));
assert!(
matches!(action, RouteAction::Msg(ref message) if matches!(**message, Msg::Key(_))),
"got {action:?}"
);
}
/// The start screen takes text, so Esc never quits it — that is how a half-typed prompt gets lost
/// by reflex. Ctrl+C does, as it does everywhere.
#[test]
fn test_route_key_dashboard_esc_stays_and_ctrl_c_quits() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
let dash = DashboardState::new(vec![SessionSummary {
id: "s1".to_string(),
name: "Session one".to_string(),
age: "now".to_string(),
search_text: "Session one prompt".to_string(),
preview: Vec::new(),
worktree: None,
}]);
app.enter_dashboard(dash);
let action = route_key(&mut app, &key(KeyCode::Esc));
assert!(
matches!(action, RouteAction::Dashboard(luxe_tui::dashboard::DashOutcome::None)),
"got {action:?}"
);
let quit = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL);
let action = route_key(&mut app, &quit);
assert!(
matches!(action, RouteAction::Dashboard(luxe_tui::dashboard::DashOutcome::Quit)),
"got {action:?}"
);
}
/// The project-context list owns the keys and the pointer while it is up.
///
/// Opening it does not change the view mode — the dashboard stays behind it on purpose — and the
/// routing asked for the view mode. So the arrows walked the column *underneath* the overlay, a
/// click reached the menu through it, and Esc quit Luxe instead of closing the list.
#[test]
fn the_project_context_list_takes_the_keys_from_the_dashboard_behind_it() {
let mut app = seeded_app("nord", FixtureScenario::DashboardContextFiles).expect("the fixture");
app.update(Msg::TerminalResized { width: 160, height: 40 });
let backend = test_backend(160, 40);
render_app(&mut app, &backend);
let selected = |a: &App| a.overlays.context_files.as_ref().expect("list open").selected();
assert_eq!(selected(&app), 0);
for code in [KeyCode::Down, KeyCode::Char('j'), KeyCode::Tab] {
let action = route_key(&mut app, &key(code));
match action {
RouteAction::Msg(message) => app.update(*message),
other => panic!("{code:?} escaped the list: {other:?}"),
}
}
assert_eq!(selected(&app), 2, "j and ↓ walk the list; Tab is not its key");
assert!(app.editor.current_input().is_empty(), "and the prompt underneath typed nothing");
// Esc puts the list away rather than quitting Luxe.
let action = route_key(&mut app, &key(KeyCode::Esc));
match action {
RouteAction::Msg(message) => app.update(*message),
other => panic!("Esc left the list: {other:?}"),
}
assert!(app.overlays.context_files.is_none());
assert!(!app.should_quit);
assert_eq!(app.current_view, ViewMode::Dashboard);
// And a click lands on the row it is over, opening it the way Enter does.
let mut app = seeded_app("nord", FixtureScenario::DashboardContextFiles).expect("the fixture");
app.update(Msg::TerminalResized { width: 160, height: 40 });
let buffer = render_app(&mut app, &backend);
let row = (0..buffer.area.height)
.find(|&y| {
(0..buffer.area.width)
.map(|x| buffer[(x, y)].symbol())
.collect::<String>()
.contains("release-notes")
})
.expect("the fixture lists a skill");
click_cell(&mut app, buffer.area.width / 2, row, std::time::Instant::now());
assert_eq!(
app.outbox.editor_file.take(),
Some(std::path::PathBuf::from("/repo/.luxe/skills/release-notes/SKILL.md")),
"a click opens the row it landed on"
);
}
/// With nothing configured, setup leads the list and Enter opens the surface that answers it — and
/// the dashboard is not drawn underneath.
#[test]
fn test_route_key_dashboard_configuration_opens_the_setup_surface() {
let mut app = create_app();
let mut dashboard = DashboardState::new(Vec::new());
dashboard.set_provider_configured(false);
app.enter_dashboard(dashboard);
let action = route_key(&mut app, &key(KeyCode::Enter));
assert!(
matches!(action, RouteAction::Dashboard(luxe_tui::dashboard::DashOutcome::OpenConfig)),
"got {action:?}"
);
let RouteAction::Dashboard(outcome) = action else { unreachable!() };
app.handle_dashboard_outcome(outcome);
assert_eq!(app.current_view, ViewMode::Configuration);
assert!(app.overlays.configuration.is_some());
let backend = test_backend(120, 40);
let buffer = render_app(&mut app, &backend);
let screen: String = buffer.content.iter().map(|cell| cell.symbol()).collect();
assert!(screen.contains("Configuration"), "{screen}");
assert!(!screen.contains("New session"), "the dashboard is gone, not behind it: {screen}");
}
/// The whole point of the surface: a login opens *in* it, so nothing is ever half-covered.
#[test]
fn a_login_started_from_configuration_draws_inside_the_surface() {
let mut app = seeded_app("nord", FixtureScenario::Configuration).expect("the fixture");
app.update(Msg::TerminalResized { width: 120, height: 40 });
let backend = test_backend(120, 40);
let text =
|buffer: &Buffer| -> String { buffer.content.iter().map(|cell| cell.symbol()).collect() };
// Row one: sign in to a subscription.
match route_key(&mut app, &key(KeyCode::Enter)) {
RouteAction::Configuration(outcome) => app.apply_configuration_outcome(outcome),
other => panic!("expected a configuration outcome, got {other:?}"),
}
assert!(app.overlays.auth_wizard.is_some());
let screen = text(&render_app(&mut app, &backend));
assert!(screen.contains("Sign in to a subscription"), "{screen}");
assert!(
!screen.contains("Edit configuration files"),
"the menu gave up its region rather than sitting behind the panel: {screen}"
);
// Escape returns to the menu it was chosen from, not out of the surface.
app.update(Msg::Key(key(KeyCode::Esc)));
assert!(app.overlays.auth_wizard.is_none());
assert_eq!(app.current_view, ViewMode::Configuration);
assert!(text(&render_app(&mut app, &backend)).contains("Edit configuration files"));
}
/// Choosing a model is the last step of setting a provider up, so a login that landed walks into
/// it by itself, in the same region — and it has to be *drawn*: an overlay that owns the keyboard
/// while invisible is the worst of both.
#[test]
fn a_finished_login_walks_into_the_model_picker_inside_the_surface() {
use luxe_tui::fixture::{seed_login_wizard, LoginFixture};
let mut app = seeded_app("nord", FixtureScenario::Configuration).expect("the fixture");
app.update(Msg::TerminalResized { width: 120, height: 40 });
seed_login_wizard(&mut app, LoginFixture::Done);
assert!(app.overlays.auth_wizard.is_none(), "success is not a screen to dismiss");
assert!(app.overlays.model_picker.is_some(), "a finished login opens the model picker itself");
let backend = test_backend(120, 40);
let buffer = render_app(&mut app, &backend);
let screen: String = buffer.content.iter().map(|cell| cell.symbol()).collect();
assert!(screen.contains("Select model"), "{screen}");
assert!(screen.contains("GPT-5.6"), "{screen}");
// What the login had to say rides along as the picker's opening line rather than being lost
// with the screen that used to report it — including which model it left the session on, so
// the preselected row does not read as a choice nobody made.
assert!(screen.contains("Signed in to OpenAI"), "{screen}");
assert!(screen.contains("Now on GPT-5.6"), "{screen}");
// The count of models is not on it: they are the rows underneath.
assert!(!screen.contains("47 models available"), "{screen}");
}
/// Esc in the SessionPicker closes it (even without a live picker).
#[test]
fn test_route_key_session_picker_esc_closes() {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.current_view = ViewMode::SessionPicker;
let action = route_key(&mut app, &key(KeyCode::Esc));
assert!(matches!(action, RouteAction::PickerClosed), "got {action:?}");
}
/// Guided Review: row and page keys move the diff window rather than the composer.
///
/// One meaning per key, in every state the surface can be in. These used to be conditional on
/// which pane held focus, which is how `↑`/`↓` came to do nothing at all on the landing surface.
#[test]
fn test_route_key_guided_review_navigation_moves_diff_rows() {
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width: 160, height: 44 });
assert!(matches!(claim(&mut app, &key(KeyCode::Down)), Some(Msg::GuidedReviewLineNext)));
assert!(matches!(claim(&mut app, &key(KeyCode::Up)), Some(Msg::GuidedReviewLinePrevious)));
assert!(matches!(
claim(&mut app, &KeyEvent::new(KeyCode::Down, KeyModifiers::CONTROL)),
Some(Msg::GuidedReviewFileNext)
));
assert!(matches!(
claim(&mut app, &KeyEvent::new(KeyCode::Up, KeyModifiers::CONTROL)),
Some(Msg::GuidedReviewFilePrevious)
));
assert!(matches!(claim(&mut app, &key(KeyCode::PageDown)), Some(Msg::GuidedReviewPageNext)));
assert!(matches!(claim(&mut app, &key(KeyCode::PageUp)), Some(Msg::GuidedReviewPagePrevious)));
assert!(matches!(claim(&mut app, &key(KeyCode::Char(' '))), Some(Msg::GuidedReviewHunkNext)));
assert!(matches!(claim(&mut app, &key(KeyCode::Right)), Some(Msg::GuidedReviewColumnNext)));
assert!(matches!(claim(&mut app, &key(KeyCode::Left)), Some(Msg::GuidedReviewColumnPrevious)));
// Chords the keymap owns fall through to it rather than being claimed here.
for bound in [
key(KeyCode::Char('n')),
key(KeyCode::Char(']')),
key(KeyCode::Char('[')),
key(KeyCode::Home),
KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL),
KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT),
] {
assert!(claim(&mut app, &bound).is_none(), "{bound:?} belongs to the keymap");
}
// And the key the surface retired answers with nothing rather than something surprising: Tab
// used to move focus, and a focus move that quietly became a pane move would be worse than a
// key that does nothing.
assert!(
matches!(claim(&mut app, &key(KeyCode::Tab)), Some(Msg::Tick)),
"Tab is swallowed, never leaked to the composer"
);
}
/// The Guided Review surface is borderless (it reads as the same canvas as chat), while its
/// overlays keep the shared rounded panel corners (`PANEL_BORDER_TYPE`).
#[test]
fn guided_review_surface_is_borderless_and_overlays_use_rounded_corners() {
let (width, height) = (140, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
// Borderless surface: no outer frame corners anywhere (only the thin rail divider remains).
let buffer = render_app(&mut app, &backend);
let any_frame_corner = (0..width)
.flat_map(|x| (0..height).map(move |y| (x, y)))
.any(|(x, y)| matches!(buffer[(x, y)].symbol(), "╭" | "╮" | "╰" | "╯"));
assert!(!any_frame_corner, "the review surface must be borderless");
// Opening the help overlay adds an interior rounded panel — proves overlays are rounded too.
app.update(Msg::GuidedReviewToggleHelp);
let with_help = render_app(&mut app, &backend);
let interior_rounded_corner = (1..width - 1)
.flat_map(|x| (1..height - 1).map(move |y| (x, y)))
.any(|(x, y)| with_help[(x, y)].symbol() == "╭");
assert!(interior_rounded_corner, "help overlay must render a rounded top-left corner");
let any_square_corner = (0..width)
.flat_map(|x| (0..height).map(move |y| (x, y)))
.any(|(x, y)| matches!(with_help[(x, y)].symbol(), "┌" | "┐" | "└" | "┘"));
assert!(!any_square_corner, "no Guided Review panel may use square corners");
}
/// Region-precise wheel: after a render publishes the hit regions, a notch over the guide scrolls
/// the guide's own prose, and over the diff scrolls source lines.
///
/// The guide's wheel used to walk the file selection, which made reading the section you were not
/// standing in impossible — every notch dragged the review's position along with the view.
#[test]
fn wheel_over_review_panes_scrolls_the_surface_under_the_cursor() {
use crossterm::event::{MouseEvent, MouseEventKind};
let (width, height) = (140, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.update(Msg::TerminalResized { width, height });
let _ = render_app(&mut app, &backend); // publishes app.hit scroll regions
let wheel = |kind, column| MouseEvent { kind, column, row: 6, modifiers: KeyModifiers::NONE };
// Left rail (guide pane) -> the prose scrolls; the cursor is not what moves.
assert!(matches!(
route_mouse(&mut app, &wheel(MouseEventKind::ScrollDown, 5)),
RouteAction::Msg(message) if matches!(*message, Msg::GuidedReviewScrollGuide { up: false })
));
// Right pane (diff) -> line scroll.
assert!(matches!(
route_mouse(&mut app, &wheel(MouseEventKind::ScrollUp, 90)),
RouteAction::Msg(message) if matches!(*message, Msg::GuidedReviewLinePrevious)
));
}

View File

@@ -0,0 +1,509 @@
//! Selection — thinking output, drags, double clicks and folding by click.
use super::*;
/// Reasoning renders muted + italic: the body carries `Modifier::ITALIC` in the `thinkingText`
/// color, and the collapsed block shows a one-line peek rather than the full body. The styling is
/// the whole cue — no "thinking" banner is printed above it.
#[test]
fn thinking_output_is_muted_italic_with_a_collapsed_peek() {
use ratatui::style::Modifier;
let (width, height) = (120, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::ChatThinking).unwrap();
let thinking_fg = app.theme_styles.thinking_text.fg.expect("thinkingText color");
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &backend);
assert!(
!buffer_to_string(&buffer).contains("thinking"),
"the redundant reasoning label is gone"
);
// A word only the reasoning body says is italic in the muted color.
let body_row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("partial"))
.expect("the reasoning body renders");
let text = row_text(&buffer, body_row, width);
let col = text.find("partial").expect("the reasoning token") as u16;
assert!(
buffer[(col, body_row)].modifier.contains(Modifier::ITALIC),
"reasoning renders in italic"
);
assert_eq!(buffer[(col, body_row)].fg, thinking_fg, "reasoning uses the thinkingText color");
// The collapsed block peeks at its rendered first line and says what it is standing in for.
let content = buffer_to_string(&buffer);
assert!(
content.contains("Planning the test · +1 more line"),
"the collapsed peek shows the section title and the count: {content}"
);
assert!(
!content.contains("single case"),
"the collapsed block hides the rest of the reasoning body"
);
}
/// Reasoning is markdown in practice, so it renders as markdown: the `**title**` a GPT model leads
/// each section with becomes a bold title in the reasoning color, and a backticked symbol takes the
/// theme's code hue. The syntax that produced either one never reaches the screen.
#[test]
fn thinking_output_renders_its_markdown_without_showing_the_syntax() {
use ratatui::style::Modifier;
let (width, height) = (120, 40);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::ChatThinking).unwrap();
let thinking_fg = app.theme_styles.thinking_text.fg.expect("thinkingText color");
let code_fg = app.theme_styles.md_code.fg.expect("mdCode color");
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("Tracing the buffering"), "the section title renders: {content}");
assert!(
!content.contains("**") && !content.contains('`'),
"no markdown syntax survives into the transcript: {content}"
);
let cell = |needle: &str| {
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains(needle))
.unwrap_or_else(|| panic!("{needle} renders: {content}"));
let col = row_text(&buffer, row, width).find(needle).expect("the column") as u16;
&buffer[(col, row)]
};
let title = cell("Tracing the buffering");
assert!(title.modifier.contains(Modifier::BOLD), "a reasoning title is bold");
assert!(title.modifier.contains(Modifier::ITALIC), "and stays in the reasoning voice");
assert_eq!(title.fg, thinking_fg, "a title spends weight rather than a color");
// `Parser::feed` appears in both an answer and the reasoning above it, so pick the reasoning
// line by something only it says.
let code_row = (0..height)
.find(|&y| {
let text = row_text(&buffer, y, width);
text.contains("Parser::feed") && text.contains("whole input")
})
.expect("the reasoning line naming the symbol");
let code_col = row_text(&buffer, code_row, width).find("Parser::feed").expect("the column");
let code = &buffer[(code_col as u16, code_row)];
assert_eq!(code.fg, code_fg, "a backticked symbol keeps the code hue inside reasoning");
assert!(code.modifier.contains(Modifier::ITALIC), "and is still italic");
// A list the model wrote renders as one, in the reasoning color.
let bullet = cell("• a multi-byte token");
assert_eq!(bullet.fg, thinking_fg, "a reasoning list marker takes the reasoning color");
}
/// Capturing the mouse takes the terminal's own click-drag selection away, so a drag over the
/// transcript must select, highlight, and copy in-app.
#[test]
fn dragging_over_the_transcript_selects_highlights_and_copies() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (60, 12);
let backend = test_backend(width, height);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("alpha bravo charlie".into()));
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("alpha bravo charlie"))
.expect("the reply renders");
let start_col = column_of(&row_text(&buffer, row, width), "bravo");
let event = |kind, column, row| MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let press = event(MouseEventKind::Down(MouseButton::Left), start_col, row);
let action = route_mouse(&mut app, &press);
apply(&mut app, action);
assert!(app.pointer.selection_drag.is_some(), "a press on the transcript anchors a selection");
let drag = event(MouseEventKind::Drag(MouseButton::Left), start_col + 5, row);
let action = route_mouse(&mut app, &drag);
apply(&mut app, action);
let selection = app.pointer.selection.clone().expect("the drag records a selection");
assert!(!selection.grid.is_empty());
// The dragged cells render with the selection background.
let buffer = render_app(&mut app, &backend);
let selected_bg = app.theme_styles.selected_bg.bg.expect("selection background");
assert_eq!(buffer[(start_col, row)].bg, selected_bg, "the first selected cell is highlighted");
assert_ne!(
buffer[(start_col + 6, row)].bg,
selected_bg,
"cells past the selection stay unstyled"
);
// Releasing copies, exactly like a terminal's copy-on-select, and says so — the clipboard
// itself is invisible.
let release = event(MouseEventKind::Up(MouseButton::Left), start_col + 5, row);
let action = route_mouse(&mut app, &release);
apply(&mut app, action);
let buffer = render_app(&mut app, &backend);
assert_eq!(app.outbox.copy.as_deref(), Some("bravo"));
assert!(app.pointer.selection_drag.is_none(), "the drag ends on release");
assert!(
buffer_to_string(&buffer).contains("Copied to clipboard"),
"the row above the prompt should confirm the copy: {}",
buffer_to_string(&buffer)
);
// Esc drops the selection instead of reaching the composer.
app.update(Msg::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)));
assert!(app.pointer.selection.is_none(), "Esc clears the selection");
}
/// An overlay drawn over the transcript takes it out of reach: a press on the overlay's own padding
/// must not start a selection in the message hidden behind it, and a drag there must not copy it.
#[test]
fn an_open_overlay_stops_the_transcript_offering_text_and_clicks() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.push_convo(ConvoBlock::Assistant("alpha bravo charlie".into()));
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("alpha bravo charlie"))
.expect("the reply renders");
// Ctrl+K opens the command palette over the chat surface.
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL)));
render_app(&mut app, &backend);
let event = |kind| MouseEvent { kind, column: 4, row, modifiers: KeyModifiers::NONE };
for kind in [
MouseEventKind::Down(MouseButton::Left),
MouseEventKind::Drag(MouseButton::Left),
MouseEventKind::Up(MouseButton::Left),
] {
let action = route_mouse(&mut app, &event(kind));
apply(&mut app, action);
}
assert!(app.pointer.selection.is_none(), "no selection starts behind the overlay");
render_app(&mut app, &backend);
assert!(app.outbox.copy.is_none(), "and nothing hidden is copied");
}
/// A selection has to survive the transcript moving under it. Output arriving, a card opening — the
/// line indices it was made from are stale within a frame, so each end is pinned to the transcript
/// line it landed on and re-found every frame. Dropping the selection instead made it impossible to
/// copy anything out of a session that was still streaming.
#[test]
fn a_transcript_selection_survives_new_output_above_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (60, 20);
let backend = test_backend(width, height);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("alpha bravo charlie".into()));
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("alpha bravo charlie"))
.expect("the reply renders");
let start_col = column_of(&row_text(&buffer, row, width), "bravo");
let event = |kind, column| MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let action = route_mouse(&mut app, &event(MouseEventKind::Down(MouseButton::Left), start_col));
apply(&mut app, action);
let action =
route_mouse(&mut app, &event(MouseEventKind::Drag(MouseButton::Left), start_col + 5));
apply(&mut app, action);
let before = app.pointer.selection.clone().expect("the drag records a selection");
// Two new blocks land above nothing and below everything, and the *first* block grows — which
// moves every rendered line under the selection.
app.convo[0]
.set_block(ConvoBlock::Assistant("alpha bravo charlie\n\nand a second paragraph".into()));
app.push_convo(ConvoBlock::System("a later line".into()));
let buffer = render_app(&mut app, &backend);
let after = app.pointer.selection.clone().expect("the selection survives the reflow");
assert_eq!(after.pins, before.pins, "it is pinned to the same transcript lines");
assert_eq!(
after.grid.bounds().0.column,
before.grid.bounds().0.column,
"and covers the same columns"
);
// Still the same cells on screen, and still what the release copies.
let moved_row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("alpha bravo charlie"))
.expect("the reply still renders");
let selected_bg = app.theme_styles.selected_bg.bg.expect("selection background");
assert_eq!(buffer[(start_col, moved_row)].bg, selected_bg, "the same word stays highlighted");
let action =
route_mouse(&mut app, &event(MouseEventKind::Up(MouseButton::Left), start_col + 5));
apply(&mut app, action);
render_app(&mut app, &backend);
assert_eq!(app.outbox.copy.as_deref(), Some("bravo"));
}
/// Double-click grabs the word under the pointer, triple-click the whole line — the two gestures
/// mouse capture takes away from the terminal. Both copy on release, like any other selection.
#[test]
fn a_double_click_takes_the_word_and_a_triple_click_the_line() {
let (width, height) = (60, 12);
let backend = test_backend(width, height);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("call Parser::feed on it".into()));
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Parser::feed"))
.expect("the reply renders");
let column = column_of(&row_text(&buffer, row, width), "Parser") + 3;
let now = std::time::Instant::now();
// Chained presses on one cell escalate: the first is a caret, the second the word.
click_cell(&mut app, column, row, now);
assert!(app.outbox.copy.is_none(), "one click selects nothing to copy");
click_cell(&mut app, column, row, now);
render_app(&mut app, &backend);
assert_eq!(
app.outbox.copy.as_deref(),
Some("Parser::feed"),
"a double-click takes the whole symbol, colons included"
);
// A third press takes the line — padding trimmed, since nobody wants the band on the clipboard.
app.outbox.copy = None;
click_cell(&mut app, column, row, now);
render_app(&mut app, &backend);
assert_eq!(app.outbox.copy.as_deref(), Some("call Parser::feed on it"));
// Far enough apart, the chain breaks and each press is its own caret again.
app.outbox.copy = None;
click_cell(&mut app, column, row, now + std::time::Duration::from_secs(1));
render_app(&mut app, &backend);
assert!(app.outbox.copy.is_none(), "a late click is a fresh single click");
}
/// The composer answers the same two gestures, over its own buffer.
#[test]
fn a_double_click_in_the_composer_takes_the_word_under_it() {
let (width, height) = (60, 12);
let backend = test_backend(width, height);
let mut app = create_app();
app.editor.insert_text("edit crates/luxe-tui/src/view.rs now");
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("view.rs"))
.expect("the draft renders");
let column = column_of(&row_text(&buffer, row, width), "crates") + 2;
let now = std::time::Instant::now();
click_cell(&mut app, column, row, now);
click_cell(&mut app, column, row, now);
assert_eq!(
app.outbox.copy.as_deref(),
Some("crates/luxe-tui/src/view.rs"),
"a double-click takes the whole path"
);
app.outbox.copy = None;
click_cell(&mut app, column, row, now);
assert_eq!(app.editor.selected_text().as_deref(), Some("edit crates/luxe-tui/src/view.rs now"));
}
/// A click on a block that is holding something back opens it — the mouse equivalent of the expand
/// chord, and the reason a truncated card's footer names both.
#[test]
fn clicking_a_truncated_card_expands_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let content = (1..=30).map(|n| format!("let value_{n} = {n};")).collect::<Vec<_>>().join("\n");
let mut card = card_with_arguments(
"write",
"src/generated.rs",
serde_json::json!({"path": "src/generated.rs", "content": content}),
);
card.activity.output_preview = Some("Created 'src/generated.rs' (620 bytes)".into());
app.push_convo(ConvoBlock::Tool(Box::new(card)));
let buffer = render_app(&mut app, &backend);
assert!(!buffer_to_string(&buffer).contains("let value_11"), "the card starts truncated");
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("write src/generated.rs"))
.expect("the card header renders");
let press = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: 10,
row,
modifiers: KeyModifiers::NONE,
};
let now = std::time::Instant::now();
let action = route_mouse_at(&mut app, &press, now);
assert!(matches!(action, RouteAction::None), "the press only anchors a selection");
apply(&mut app, action);
let release = MouseEvent { kind: MouseEventKind::Up(MouseButton::Left), ..press };
let action = route_mouse_at(&mut app, &release, now);
apply(&mut app, action);
let buffer = render_app(&mut app, &backend);
assert!(
buffer_to_string(&buffer).contains("let value_11"),
"the click opened the card: {}",
buffer_to_string(&buffer)
);
assert!(app.outbox.copy.is_none(), "opening a card copies nothing");
// A later click on the header closes it again. The card grew and a short transcript grows
// upward, so the header has to be found again each time rather than assumed to have stayed put.
let row_of = |app: &mut App, needle: &str| {
let buffer = render_app(app, &backend);
(0..height)
.find(|&y| row_text(&buffer, y, width).contains(needle))
.unwrap_or_else(|| panic!("{needle} renders: {}", buffer_to_string(&buffer)))
};
let header = row_of(&mut app, "write src/generated.rs");
click_cell(&mut app, 10, header, now + std::time::Duration::from_secs(1));
let buffer = render_app(&mut app, &backend);
assert!(!buffer_to_string(&buffer).contains("let value_11"), "a second click re-collapses it");
// A click on the card's *body* selects text instead of folding it away: collapsing the card out
// from under a double-click is how you make a path in it impossible to grab.
let header = row_of(&mut app, "write src/generated.rs");
click_cell(&mut app, 10, header, now + std::time::Duration::from_secs(2));
let body = row_of(&mut app, "let value_2 = 2;");
click_cell(&mut app, 10, body, now + std::time::Duration::from_secs(3));
let buffer = render_app(&mut app, &backend);
assert!(buffer_to_string(&buffer).contains("let value_11"), "the card stays open");
}
/// The footer says "click or Ctrl+O to expand", so clicking the footer has to expand. A hint that
/// names an affordance the row itself does not offer is worse than no hint.
#[test]
fn clicking_the_truncation_footer_expands_the_card() {
let (width, height) = (100, 40);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
let content = (1..=30).map(|n| format!("let value_{n} = {n};")).collect::<Vec<_>>().join("\n");
app.push_convo(ConvoBlock::Tool(Box::new(card_with_arguments(
"write",
"src/generated.rs",
serde_json::json!({"path": "src/generated.rs", "content": content}),
))));
let buffer = render_app(&mut app, &backend);
let footer = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("click or ctrl+o to expand"))
.expect("the truncation footer renders");
click_cell(&mut app, 10, footer, std::time::Instant::now());
let buffer = render_app(&mut app, &backend);
assert!(
buffer_to_string(&buffer).contains("let value_30"),
"the footer's own click opened the card: {}",
buffer_to_string(&buffer)
);
}
/// The same click opens a collapsed reasoning block, which is the other thing in the transcript
/// with a body behind a one-line peek.
#[test]
fn clicking_a_collapsed_reasoning_block_expands_it() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (100, 30);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::TerminalResized { width, height });
app.push_convo(ConvoBlock::Thinking {
text: "**Checking the config**\n\nStart with the loader, then the merge order.".into(),
expanded: false,
});
let buffer = render_app(&mut app, &backend);
assert!(!buffer_to_string(&buffer).contains("merge order"), "it starts collapsed");
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("Checking the config"))
.expect("the peek renders");
let event = |kind| MouseEvent { kind, column: 5, row, modifiers: KeyModifiers::NONE };
for kind in [MouseEventKind::Down(MouseButton::Left), MouseEventKind::Up(MouseButton::Left)] {
let action = route_mouse(&mut app, &event(kind));
apply(&mut app, action);
}
let buffer = render_app(&mut app, &backend);
assert!(
buffer_to_string(&buffer).contains("merge order"),
"the click expanded the reasoning: {}",
buffer_to_string(&buffer)
);
}
/// The composer owns its own selection (buffer offsets), highlights it, and copies on release.
#[test]
fn dragging_in_the_composer_selects_and_copies_the_draft_text() {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
let (width, height) = (60, 12);
let backend = test_backend(width, height);
let mut app = create_app();
app.editor.insert_text("select this text");
let buffer = render_app(&mut app, &backend);
let row = (0..height)
.find(|&y| row_text(&buffer, y, width).contains("select this text"))
.expect("the draft renders");
let start_col = column_of(&row_text(&buffer, row, width), "this");
let event = |kind, column| MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let action = route_mouse(&mut app, &event(MouseEventKind::Down(MouseButton::Left), start_col));
apply(&mut app, action);
let action =
route_mouse(&mut app, &event(MouseEventKind::Drag(MouseButton::Left), start_col + 9));
apply(&mut app, action);
assert_eq!(app.editor.selected_text().as_deref(), Some("this text"));
let buffer = render_app(&mut app, &backend);
let selected_bg = app.theme_styles.selected_bg.bg.expect("selection background");
assert_eq!(buffer[(start_col, row)].bg, selected_bg, "the composer paints its selection");
let action =
route_mouse(&mut app, &event(MouseEventKind::Up(MouseButton::Left), start_col + 9));
apply(&mut app, action);
assert_eq!(app.outbox.copy.as_deref(), Some("this text"));
// Typing replaces the selection, the way every other editor behaves.
app.update(Msg::Key(KeyEvent::new(KeyCode::Char('X'), KeyModifiers::NONE)));
assert_eq!(app.editor.current_input(), "select X");
}
/// Hovering a list row moves the same highlight the arrow keys would.
#[test]
fn hovering_a_picker_row_moves_the_keyboard_selection() {
use crossterm::event::{MouseEvent, MouseEventKind};
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::Key(key(KeyCode::Char('/'))));
let buffer = render_app(&mut app, &backend);
let rows: Vec<u16> =
(0..height).filter(|&y| row_text(&buffer, y, width).contains('❯')).collect();
assert_eq!(rows.len(), 1, "exactly one row carries the selection cursor");
let selected_row = rows[0];
let other_row = selected_row + 1;
let moved = MouseEvent {
kind: MouseEventKind::Moved,
column: 4,
row: other_row,
modifiers: KeyModifiers::NONE,
};
let action = route_mouse(&mut app, &moved);
apply(&mut app, action);
let buffer = render_app(&mut app, &backend);
assert!(
row_text(&buffer, other_row, width).contains('❯'),
"the hovered row takes the selection cursor"
);
assert!(
!row_text(&buffer, selected_row, width).contains('❯'),
"the previously selected row gives it up"
);
}

View File

@@ -0,0 +1,255 @@
//! Steering — a message sent mid-turn, recalled, queued or never delivered.
use super::*;
/// A mid-turn submission steers by default: it's pinned above the composer and handed to the
/// running turn, without resetting turn state or entering the transcript before it lands.
#[test]
fn a_message_sent_mid_turn_steers_instead_of_starting_a_turn() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let (tx, mut rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
// A live session, so the committed steer below is accepted the way the runtime sends it.
app.update(Msg::Engine(luxe_core::event::Event::SessionLoaded {
session_id: "session-a".into(),
messages: vec![],
}));
// A turn is running: the status clock is ticking.
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
let started = app.status.turn_started.expect("the turn clock is running");
app.editor.insert_text("actually, check the tests too");
app.update(Msg::Key(key(KeyCode::Enter)));
match rx.try_recv().expect("a steer action reaches the engine") {
luxe_core::engine::Action::SteerTurn { content } => {
assert_eq!(content, "actually, check the tests too");
}
other => panic!("expected SteerTurn, got {other:?}"),
}
assert_eq!(app.status.turn_started, Some(started), "steering must not restart the turn clock");
// Held above the composer, not dropped into the transcript where the turn's own output would
// scroll it away.
assert_eq!(app.pending_submissions.len(), 1);
assert!(
!app.convo.iter().any(|item| matches!(item.block(), ConvoBlock::User { .. })),
"a steer isn't a transcript message until it lands"
);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("steering"), "the tray says what's pending: {content}");
assert!(content.contains("check the tests too"), "and shows the message: {content}");
// Delivery is announced twice by design: the engine commits the steer as a real user entry
// (`MessageCommitted`, which carries the persisted id) and then reports the delivery. Exactly
// one transcript row may come out of that pair — landing both is what showed every steer twice.
app.update(Msg::Engine(luxe_core::event::Event::MessageCommitted {
session_id: "session-a".into(),
entry_id: luxe_core::session::EntryId("entry-steer".into()),
message: luxe_core::message::Message::user("actually, check the tests too"),
}));
app.update(Msg::Engine(luxe_core::event::Event::SteeringDelivered { count: 1 }));
assert!(app.pending_submissions.is_empty(), "the tray row retires on delivery");
let steers = app
.convo
.iter()
.filter(|item| {
matches!(item.block(), ConvoBlock::User { text, .. } if text == "actually, check the tests too")
})
.count();
assert_eq!(steers, 1, "the delivered steer appears exactly once in the transcript");
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(!content.contains("steering"), "the tray row retires on delivery: {content}");
assert!(content.contains("check the tests too"), "the message stays, in the transcript");
}
/// Cancelling hands a steer the engine never took in back to the composer.
///
/// A message that never ran belongs somewhere it can be fixed and re-sent, not in the transcript as
/// a read-only row — interrupting is usually the first half of "let me put that differently". The
/// engine has to be told as well: a steer is admitted the moment it is submitted, so a UI that only
/// cleared its own tray would leave the recalled text queued for the next turn's first checkpoint.
#[test]
fn a_cancelled_steer_comes_back_to_the_composer() {
let (tx, mut rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
app.editor.insert_text("never mind, stop");
app.update(Msg::Key(key(KeyCode::Enter)));
assert!(matches!(rx.try_recv(), Ok(luxe_core::engine::Action::SteerTurn { .. })));
assert_eq!(app.editor.current_input(), "", "submitting cleared the draft");
app.update(Msg::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::CONTROL)));
assert!(app.pending_submissions.is_empty(), "nothing is left waiting");
assert_eq!(app.editor.current_input(), "never mind, stop", "and it is editable again");
assert!(
!app.convo.iter().any(
|item| matches!(item.block(), ConvoBlock::User { text, .. } if text == "never mind, stop")
),
"a message that never ran is not transcript history"
);
let sent: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
assert!(
sent.iter().any(|action| matches!(action, luxe_core::engine::Action::Cancel)),
"the turn is still cancelled: {sent:?}"
);
assert!(
sent.iter().any(|action| matches!(action, luxe_core::engine::Action::WithdrawSteering)),
"and the engine drops the steer it had buffered: {sent:?}"
);
}
/// Alt+Up takes back everything waiting, in the order it was typed, ahead of the current draft.
#[test]
fn the_recall_key_returns_every_waiting_message_to_the_composer() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let (tx, mut rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
app.editor.insert_text("also check the reconnect backoff");
app.update(Msg::Key(key(KeyCode::Enter)));
app.editor.insert_text("then update the architecture doc");
app.update(Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT)));
assert_eq!(app.pending_submissions.len(), 2, "one steer, one follow-up");
// The tray says which key brings them back, or the feature is invisible.
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("alt+up to edit them here"), "{content}");
app.editor.insert_text("and a half-typed third");
app.update(Msg::Key(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT)));
assert!(app.pending_submissions.is_empty(), "the tray empties");
assert_eq!(
app.editor.current_input(),
"also check the reconnect backoff\n\nthen update the architecture doc\n\nand a half-typed third",
"restored in submission order, before what was being typed"
);
let sent: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
assert!(
sent.iter().any(|action| matches!(action, luxe_core::engine::Action::WithdrawSteering)),
"the buffered steer is withdrawn: {sent:?}"
);
// Pressing it again has nothing to take back, and says so rather than reading as a dead key.
app.update(Msg::Key(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT)));
let content = buffer_to_string(&render_app(&mut app, &backend));
assert!(content.contains("Nothing waiting to restore"), "{content}");
}
/// A steer that could not be sent at all still shows up, marked as never sent.
///
/// The one remaining path to that marker: with the engine gone there is nothing to recall from and
/// nothing that will ever deliver it, so the transcript is where it has to be said.
#[test]
fn a_steer_the_engine_never_received_is_marked_never_sent() {
let (tx, rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
drop(rx);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
app.editor.insert_text("one more thing");
app.update(Msg::Key(key(KeyCode::Enter)));
assert!(app.pending_submissions.is_empty(), "nothing is waiting on a delivery that can't come");
let landed = app
.convo
.iter()
.find(
|item| matches!(item.block(), ConvoBlock::User { text, .. } if text == "one more thing"),
)
.expect("the undeliverable steer is in the transcript");
assert!(app.was_never_sent(&landed.id), "and is marked as never sent");
}
/// The tray holds its ground while the turn keeps streaming: a pending message must not drift up
/// with the transcript or scroll out of view before it has run.
#[test]
fn a_pending_message_stays_pinned_above_the_composer_while_output_streams() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let mut app = create_app();
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
app.editor.insert_text("one more thing");
app.update(Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT)));
let row_of_tray = |app: &mut App| {
let buffer = render_app(app, &backend);
(0..height).find(|&y| row_text(&buffer, y, width).contains("one more thing"))
};
let before = row_of_tray(&mut app).expect("the tray row renders");
for index in 0..40 {
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: format!("streamed line {index}\n"),
}));
}
let after = row_of_tray(&mut app).expect("the tray row is still on screen");
assert_eq!(before, after, "a pending message holds its row while the transcript scrolls");
}
/// Alt+Enter queues a follow-up turn instead: held (visibly, with its position) until the current
/// turn ends, then promoted one at a time.
#[test]
fn alt_enter_queues_a_follow_up_turn_promoted_when_the_turn_ends() {
let (width, height) = (80, 24);
let backend = test_backend(width, height);
let (tx, mut rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::Engine(luxe_core::event::Event::TokenDelta {
block: 0,
delta: "working".into(),
}));
app.editor.insert_text("then update the docs");
app.update(Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT)));
assert!(rx.try_recv().is_err(), "a queued message must not reach the engine yet");
assert_eq!(app.queued_count(), 1);
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("queued"), "the queued message says so: {content}");
assert!(content.contains("#1"), "and carries its position: {content}");
// The turn ends: exactly one queued message is promoted into a real turn.
app.update(Msg::Engine(luxe_core::event::Event::TurnEnded {
reason: luxe_core::event::StopReason::EndTurn,
}));
match rx.try_recv().expect("the queued message is promoted") {
luxe_core::engine::Action::SubmitUserMessage { content, .. } => {
assert_eq!(content, "then update the docs");
}
other => panic!("expected SubmitUserMessage, got {other:?}"),
}
assert_eq!(app.queued_count(), 0);
assert!(app.status.turn_started.is_some(), "promotion starts the turn clock");
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(!content.contains("queued"), "the tray row retires on promotion: {content}");
assert!(content.contains("then update the docs"), "and the message joins the transcript");
}

View File

@@ -0,0 +1,92 @@
//! Support — the app, backend and click helpers every render scenario builds on.
use super::*;
/// Helper to create a test backend with the given size.
pub(crate) fn test_backend(width: u16, height: u16) -> TestBackend {
TestBackend::new(width, height)
}
/// Cells a dock heading badge spends in front of its label: the opening cap and one pad.
///
/// The badge's *leading edge* is what lands on the panel's content margin, so a test looking for
/// the label finds it this far in. Spent at every glyph tier — below nerd the cap is a filled cell
/// rather than a chamfer, so the column does not move.
pub(crate) const DOCK_HEADING_LEAD: u16 = 2;
/// The activity bar's unspent unit — `▏`, the default `ActivityBarStyle::Bars` track glyph. How a
/// test finds the row the indicator is on.
pub(crate) const ACTIVITY_BAR_TRACK: &str = "\u{258f}";
/// Every glyph the default bar can draw — the comet's weights, tapering onto the rail's own.
pub(crate) const ACTIVITY_BAR_GLYPHS: [char; 4] = ['\u{258c}', '\u{258d}', '\u{258e}', '\u{258f}'];
/// Screen column where `needle` starts in a rendered row (cells, not bytes).
pub(crate) fn column_of(text: &str, needle: &str) -> u16 {
let byte = text.find(needle).unwrap_or_else(|| panic!("{needle:?} missing from row {text:?}"));
text[..byte].chars().count() as u16
}
/// Applies a routed mouse action the way the event loop would (the subset the mouse tests emit).
pub(crate) fn apply(app: &mut App, action: RouteAction) {
use luxe_tui::main_loop::ScrollAction;
match action {
RouteAction::Msg(message) => app.update(*message),
RouteAction::Scroll(ScrollAction::Up(lines)) => app.scroll_state.up_by(lines),
RouteAction::Scroll(ScrollAction::Down(lines)) => app.scroll_state.down_by(lines),
RouteAction::None => {}
other => panic!("unexpected route action in a mouse test: {other:?}"),
}
}
/// Presses and releases the left button at one cell, at `at` on the multi-click clock.
///
/// Two clicks a test fires back to back land microseconds apart, which is a *double*-click; passing
/// the instant is how a test says "two separate clicks" or "one deliberate double-click".
pub(crate) fn click_cell(app: &mut App, column: u16, row: u16, at: std::time::Instant) {
use crossterm::event::{MouseButton, MouseEvent, MouseEventKind};
for kind in [MouseEventKind::Down(MouseButton::Left), MouseEventKind::Up(MouseButton::Left)] {
let event = MouseEvent { kind, column, row, modifiers: KeyModifiers::NONE };
let action = route_mouse_at(app, &event, at);
apply(app, action);
}
}
/// Helper to render the app and get the buffer.
pub(crate) fn render_app(app: &mut App, backend: &TestBackend) -> Buffer {
let mut terminal = Terminal::new(backend.clone()).unwrap();
terminal
.draw(|f| {
render(f, app);
})
.unwrap();
terminal.backend().buffer().clone()
}
/// Helper to create an app with a dummy channel.
pub(crate) fn create_app() -> App {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
App::new(tx, KeyMap::defaults(), Config::default())
}
/// Helper to create an app with a specific theme.
pub(crate) fn create_app_with_config(config: Config) -> App {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
App::new(tx, KeyMap::defaults(), config)
}
/// Helper to create an app with a specific theme.
pub(crate) fn create_app_with_theme(theme: &str) -> App {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
App::new(
tx,
KeyMap::defaults(),
Config { theme: Some(theme.to_string()), ..Default::default() },
)
}
/// An app in a light palette. No built-in is light any more, but a reader's own theme can be.
pub(crate) fn create_app_with_light_theme() -> App {
let mut app = create_app_with_theme("luxe");
app.theme_styles = luxe_tui::fixture::light_theme_styles();
app
}

View File

@@ -0,0 +1,437 @@
//! Transcript — messages, cards and system notices drawn in the conversation, and how a scrolled view holds its place.
use super::*;
/// An empty conversation still draws the composer, where typing will land.
#[test]
fn an_empty_conversation_draws_the_composer() {
let backend = test_backend(80, 24);
let mut app = create_app();
let buffer = render_app(&mut app, &backend);
let (x, y) = composer_corner(&buffer);
assert!(y > 0, "the composer sits under the conversation, not at the top: ({x}, {y})");
assert_eq!(buffer[(x, y)].symbol(), "\u{256d}", "a rounded corner opens the box");
}
/// Messages draw in the order they were said, the reader's first.
#[test]
fn messages_draw_in_the_order_they_were_said() {
let backend = test_backend(80, 24);
let mut app = create_app();
app.push_convo(ConvoBlock::User {
text: "Hello".to_string(),
attached: Vec::new(),
chips: Vec::new(),
});
app.push_convo(ConvoBlock::Assistant("Hi there!".to_string()));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
let hello =
rendered.find("Hello").unwrap_or_else(|| panic!("the message is missing: {rendered}"));
let reply =
rendered.find("Hi there!").unwrap_or_else(|| panic!("the reply is missing: {rendered}"));
assert!(hello < reply, "the reader's message comes first: {rendered}");
}
/// Test rendering with a tool call.
#[test]
fn test_render_with_tool_call() {
let backend = test_backend(80, 24);
let mut app = create_app();
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity: ToolActivity::running("session-a", "call-a", "bash", "ls -la", 1),
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("ls -la"), "running command missing: {rendered}");
}
#[test]
fn expanded_tool_details_render_and_wrap_inside_the_conversation() {
let (width, height) = (48, 18);
let backend = test_backend(width, height);
let mut app = create_app();
let mut activity = ToolActivity::running("session-a", "call-a", "bash", "cargo test", 1);
activity.state = ToolActivityState::Failed;
activity.input_preview = Some("--package luxe-tui --features detailed-tools".into());
activity.output_preview =
Some("tool output must wrap inside the visible conversation pane tail".into());
activity.summary = Some("validation failed".into());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: true,
details_toggled: false,
waited_on_user_ms: 0,
})));
let buffer = render_app(&mut app, &backend);
let content = buffer_to_string(&buffer);
assert!(content.contains("arguments:"), "missing arguments detail: {content}");
assert!(content.contains("output:"), "missing output detail: {content}");
assert!(content.contains("pane tail"), "wrapped output tail was clipped: {content}");
// The outcome rides on the header line — a `result:` row underneath would say it twice.
assert!(content.contains("validation failed"), "the outcome is on the card: {content}");
assert!(!content.contains("result:"), "no redundant result row: {content}");
}
/// A question card is one exchange in two rows, so the answer has to land on the *header's*
/// columns rather than under the body indent every other card's payload uses. Measured off the
/// rendered buffer, because the columns are what a reader sees: nothing in the source says `12`.
#[test]
fn a_question_cards_answer_lines_up_with_the_question_it_answers() {
let (width, height) = (150u16, 34u16);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::ChatQuestion).expect("the fixture");
app.update(Msg::TerminalResized { width, height });
let buffer = render_app(&mut app, &backend);
let rows: Vec<String> = (0..height).map(|y| row_text(&buffer, y, width)).collect();
let asked = rows
.iter()
.find(|row| row.contains("Where should the ingest worker live?"))
.expect("the question card's header");
let answered =
rows.iter().find(|row| row.contains("its own crate")).expect("the answer under it");
assert_eq!(
column_of(asked, "question"),
column_of(answered, "answer"),
"the labels share a column:\n{asked}\n{answered}"
);
assert_eq!(
column_of(asked, "Where should"),
column_of(answered, "its own crate"),
"and so do the words they label:\n{asked}\n{answered}"
);
}
/// The reader's own decision is drawn in the reader's own color, the one a user turn takes — not in
/// the body color that would leave it indistinguishable from the question above it.
#[test]
fn a_question_cards_answer_is_drawn_in_the_color_a_user_turn_is() {
let (width, height) = (150u16, 34u16);
let backend = test_backend(width, height);
let mut app = seeded_app("nord", FixtureScenario::ChatQuestion).expect("the fixture");
app.update(Msg::TerminalResized { width, height });
let accent = app.theme_styles.accent.fg.expect("an accent color");
let text = app.theme_styles.text.fg.expect("a text color");
let buffer = render_app(&mut app, &backend);
let (x, y) = marker_position(&buffer, "its own crate", width, height);
assert_eq!(buffer[(x, y)].fg, accent, "the answer takes the user's color");
assert_ne!(accent, text, "precondition: the theme draws them differently");
}
#[test]
fn a_running_tool_card_animates_its_spinner_and_the_thumb_takes_the_accent() {
let backend = test_backend(60, 12);
let mut app = create_app();
for index in 0..30 {
app.push_convo(ConvoBlock::System(format!("filler {index}")));
}
let activity = ToolActivity::running("session-a", "call-a", "bash", "cargo test", 1);
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let frame_zero = render_app(&mut app, &backend);
let row_zero: String = frame_zero.content.iter().map(|cell| cell.symbol()).collect();
app.status.spinner_frame = 4;
let frame_four = render_app(&mut app, &backend);
let row_four: String = frame_four.content.iter().map(|cell| cell.symbol()).collect();
assert_ne!(row_zero, row_four, "the running glyph is frozen across spinner frames");
// The scrollbar thumb is the positional indicator, so it wears the accent, not the border.
let accent = app.theme_styles.accent.fg.expect("theme accent has a foreground");
let border = app.theme_styles.border.fg.expect("theme border has a foreground");
assert_ne!(accent, border, "fixture theme must distinguish accent from border");
let thumbs =
frame_four.content.iter().filter(|cell| cell.symbol() == "\u{2590}").collect::<Vec<_>>();
assert!(!thumbs.is_empty(), "a taller-than-viewport transcript draws a thumb");
assert!(
thumbs.iter().all(|cell| cell.fg == accent),
"scrollbar thumb should use the theme accent"
);
}
#[test]
fn scrolling_up_between_renders_is_not_undone_by_anchor_restore() {
// Every frame used to re-derive the offset from the *previous* frame's anchor whenever follow
// was off, so each manual scroll was reverted before it could be seen. Drive the real
// two-frame sequence: render, scroll, render.
let backend = test_backend(60, 10);
let mut app = create_app();
for index in 0..40 {
app.push_convo(ConvoBlock::System(format!("transcript line {index}")));
}
render_app(&mut app, &backend);
assert!(app.scroll_state.follow, "a fresh transcript follows the tail");
let bottom = app.scroll_state.offset;
for _ in 0..5 {
app.scroll_state.line_up();
}
assert_eq!(app.scroll_state.offset, bottom - 5);
render_app(&mut app, &backend);
assert_eq!(app.scroll_state.offset, bottom - 5, "the render pass clobbered a manual scroll");
// And it keeps moving on subsequent scrolls rather than sticking at the first position.
app.scroll_state.page_up();
let after_page = app.scroll_state.offset;
render_app(&mut app, &backend);
assert_eq!(app.scroll_state.offset, after_page);
// Scrolling back to the bottom re-arms follow, and new content sticks to the tail again.
app.scroll_state.to_bottom();
render_app(&mut app, &backend);
app.push_convo(ConvoBlock::System("fresh tail".into()));
render_app(&mut app, &backend);
assert!(app.scroll_state.follow);
assert_eq!(app.scroll_state.offset, app.scroll_state.total - app.scroll_state.viewport);
}
#[test]
fn content_growing_above_a_scrolled_viewport_keeps_the_anchored_line() {
// The other half of the contract: while scrolled up, a block *above* the viewport growing
// (tool output streaming in) must not shove the reader's position around.
let backend = test_backend(60, 10);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("first reply".into()));
for index in 0..30 {
app.push_convo(ConvoBlock::System(format!("item {index}")));
}
render_app(&mut app, &backend);
for _ in 0..8 {
app.scroll_state.line_up();
}
render_app(&mut app, &backend);
let anchored = app.conversation_anchor.clone().expect("anchor after scrolling up");
// Grow the very first block, which sits above the viewport.
app.convo[0].set_block(ConvoBlock::Assistant("first reply\n\nwith\n\nmore\n\nlines".into()));
render_app(&mut app, &backend);
let after = app.conversation_anchor.as_ref().expect("anchor after growth");
assert_eq!(after.item_id, anchored.item_id, "same item still at the top of the viewport");
assert_eq!(after.visual_line_within_item, anchored.visual_line_within_item);
}
#[test]
fn expanding_a_tool_above_the_viewport_preserves_anchor_and_selection() {
let backend = test_backend(60, 10);
let mut app = create_app();
let mut activity = ToolActivity::running("session-a", "call-a", "bash", "cargo test", 1);
activity.input_preview = Some("--package luxe-tui --features detailed-tools".into());
activity.output_preview = Some("tool output that becomes several wrapped detail lines".into());
activity.summary = Some("completed".into());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
app.push_convo(ConvoBlock::Assistant("anchored assistant reply".into()));
for index in 0..6 {
app.push_convo(ConvoBlock::System(format!("trailing item {index}")));
}
let anchor_id = app.convo[1].id.clone();
app.selected_block = Some(1);
render_app(&mut app, &backend);
// The tool renders as a padded band (top pad, line, bottom pad) and the assistant adds a
// leading gap, so its first line sits at index 3.
app.scroll_state.offset = 3;
app.scroll_state.follow = false;
app.conversation_anchor = None;
render_app(&mut app, &backend);
let before = app.conversation_anchor.clone().expect("assistant anchor before expansion");
assert_eq!(before.item_id, anchor_id);
let ConvoBlock::Tool(tool) = app.convo[0].block_mut() else {
panic!("first item must be a tool");
};
tool.expanded = true;
render_app(&mut app, &backend);
let after = app.conversation_anchor.as_ref().expect("assistant anchor after expansion");
assert_eq!(after.item_id, anchor_id);
assert_eq!(after.screen_row, before.screen_row);
assert_eq!(app.selected_block, Some(1));
}
#[test]
fn expanding_a_tool_below_the_viewport_preserves_anchor_and_selection() {
let backend = test_backend(60, 10);
let mut app = create_app();
app.push_convo(ConvoBlock::Assistant("anchored assistant reply".into()));
for index in 0..6 {
app.push_convo(ConvoBlock::System(format!("middle item {index}")));
}
let mut activity = ToolActivity::running("session-a", "call-b", "bash", "cargo test", 1);
activity.input_preview = Some("--package luxe-tui --features detailed-tools".into());
activity.output_preview = Some("tool output that becomes several wrapped detail lines".into());
activity.summary = Some("completed".into());
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
let anchor_id = app.convo[0].id.clone();
let tool_index = app.convo.len() - 1;
app.selected_block = Some(0);
render_app(&mut app, &backend);
app.scroll_state.offset = 0;
app.scroll_state.follow = false;
app.conversation_anchor = None;
render_app(&mut app, &backend);
let before = app.conversation_anchor.clone().expect("assistant anchor before expansion");
assert_eq!(before.item_id, anchor_id);
let ConvoBlock::Tool(tool) = app.convo[tool_index].block_mut() else {
panic!("last item must be a tool");
};
tool.expanded = true;
render_app(&mut app, &backend);
let after = app.conversation_anchor.as_ref().expect("assistant anchor after expansion");
assert_eq!(after.item_id, anchor_id);
assert_eq!(after.screen_row, before.screen_row);
assert_eq!(app.selected_block, Some(0));
}
#[test]
fn successful_tool_groups_collapse_and_restore_member_order() {
// The run the message asked for is what folds, so a card carries the place it was promised.
fn succeeded(call_id: &str, label: &str, index: u32) -> ToolItem {
let mut activity = ToolActivity::running("session-a", call_id, "read", label, 1);
activity.state = ToolActivityState::Succeeded;
activity.summary = Some("Completed".into());
activity.run = Some(luxe_core::ToolRun { index, total: 4 });
ToolItem { activity, expanded: false, details_toggled: false, waited_on_user_ms: 0 }
}
let backend = test_backend(80, 20);
let mut app = create_app();
for (index, (call_id, label)) in
[("call-a", "first.rs"), ("call-b", "second.rs"), ("call-c", "third.rs")]
.into_iter()
.enumerate()
{
let index = u32::try_from(index).unwrap() + 1;
app.push_convo(ConvoBlock::Tool(Box::new(succeeded(call_id, label, index))));
}
let mut failed = succeeded("call-failed", "failure.rs", 4);
failed.activity.state = ToolActivityState::Failed;
failed.activity.summary = Some("validation failed".into());
app.push_convo(ConvoBlock::Tool(Box::new(failed)));
let collapsed = buffer_to_string(&render_app(&mut app, &backend));
assert!(collapsed.contains("3 read calls"), "missing collapsed group: {collapsed}");
// Listed by name under the count, but as a list: no member draws its own card header
let listed: Vec<&str> = collapsed.lines().filter(|line| line.contains("first.rs")).collect();
assert_eq!(listed.len(), 1, "the run lists each member once: {collapsed}");
assert!(!listed[0].contains("read"), "and not as a card of its own: {collapsed}");
let order = ["first.rs", "second.rs", "third.rs"].map(|name| collapsed.find(name));
assert!(order.windows(2).all(|pair| pair[0] < pair[1]), "in order: {collapsed}");
assert!(collapsed.contains("failure.rs"), "failure must remain standalone: {collapsed}");
app.selected_block = Some(1);
assert!(app.toggle_selected_tool_details());
let expanded = buffer_to_string(&render_app(&mut app, &backend));
assert!(!expanded.contains("3 read calls"), "opened into its cards: {expanded}");
let first = expanded.find("first.rs").expect("first group member");
let second = expanded.find("second.rs").expect("second group member");
let third = expanded.find("third.rs").expect("third group member");
assert!(first < second && second < third, "group member order changed: {expanded}");
assert!(expanded.contains("failure.rs"), "failure must remain standalone: {expanded}");
}
/// Test rendering with an error state.
#[test]
fn test_render_with_error() {
let backend = test_backend(80, 24);
let mut app = create_app();
let mut item = card_with_arguments("bash", "ls", serde_json::json!({"command": "ls"}));
item.activity.state = ToolActivityState::Failed;
item.activity.summary = Some("Something went wrong".into());
app.push_convo(ConvoBlock::Tool(Box::new(item)));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("Something went wrong"), "failure missing: {rendered}");
}
#[test]
fn long_conversation_content_wraps_to_the_visible_width() {
let (width, height) = (32, 16);
let backend = test_backend(width, height);
let mut app = create_app();
app.push_convo(ConvoBlock::System(
"provider error: this deliberately long message must remain inside the conversation pane END"
.to_string(),
));
let buffer = render_app(&mut app, &backend);
let rows = (0..height).map(|y| row_text(&buffer, y, width)).collect::<Vec<_>>();
let start = rows.iter().position(|row| row.contains("provider error"));
let end = rows.iter().position(|row| row.contains("END"));
assert!(start.is_some(), "wrapped message start is missing: {rows:?}");
assert!(end.is_some(), "wrapped message tail was clipped: {rows:?}");
assert!(end > start, "long content should occupy more than one row: {rows:?}");
assert!(app.scroll_state.total >= 3);
}
/// A system message is drawn as written.
#[test]
fn a_system_message_is_drawn_as_written() {
let backend = test_backend(80, 24);
let mut app = create_app();
app.push_convo(ConvoBlock::System("Starting session...".to_string()));
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("Starting session..."), "the notice is missing: {rendered}");
}
/// The statusline names the model it was given.
#[test]
fn the_statusline_names_the_model() {
let backend = test_backend(80, 24);
let mut app = create_app();
app.status.model = "gpt-4".to_string();
app.status.context_pct = 50.0;
app.status.state = luxe_tui::app::AppState::Idle;
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("gpt-4"), "the model is missing: {rendered}");
}
/// What is typed shows in the composer.
#[test]
fn typed_text_shows_in_the_composer() {
let backend = test_backend(80, 24);
let mut app = create_app();
app.editor.insert_text("Hello, world!");
let rendered = buffer_to_string(&render_app(&mut app, &backend));
assert!(rendered.contains("Hello, world!"), "the draft is missing: {rendered}");
}

View File

@@ -0,0 +1,426 @@
//! The review always shows something.
//!
//! Every state in here rendered an *empty* content pane before: a breadcrumb naming a hunk over
//! nothing at all. Two causes, both regression-guarded here — the renderer and navigation disagreed
//! about what "folded" meant, and evidence-based accounting hid code outright.
use luxe_core::event::Event;
use luxe_core::guided_review::{
ChapterId, ChapterKind, CheckSummary, FileId, GuidedReview, HunkId, LineRange, NoiseKind,
ReviewBase, ReviewChapter, ReviewContext, ReviewFile, ReviewFileStatus, ReviewHunk, ReviewId,
ReviewItemRef, ReviewLine, ReviewLineKind, ReviewLoadRequestId, ReviewRevisionId, ReviewSource,
ReviewStats, ReviewTarget, TurnProvenance,
};
use luxe_tui::app::{App, Msg, ViewMode};
use luxe_tui::fixture::{seeded_app, FixtureScenario};
use luxe_tui::view::render;
use ratatui::backend::TestBackend;
use ratatui::Terminal;
use std::path::Path;
const WIDTH: u16 = 170;
const HEIGHT: u16 = 40;
fn text_file(path: &str, noise: NoiseKind, heading: &str) -> ReviewFile {
let id = FileId::from_path_lineage(None, Some(Path::new(path)));
let hunk_id = HunkId::from_content(&id, heading, heading);
ReviewFile {
id: id.clone(),
old_path: None,
new_path: Some(path.into()),
status: ReviewFileStatus::Modified,
language: Some("rust".into()),
additions: Some(1),
deletions: Some(0),
hunks: vec![ReviewHunk {
id: hunk_id,
old_range: LineRange::new(1, 2),
new_range: LineRange::new(1, 3),
heading: Some(heading.into()),
symbol: None,
lines: vec![
ReviewLine {
old_line: Some(1),
new_line: Some(1),
kind: ReviewLineKind::Context,
text: format!("// {heading}"),
},
ReviewLine {
old_line: None,
new_line: Some(2),
kind: ReviewLineKind::Addition,
text: format!("let {heading}_answer = 42;"),
},
],
noise,
}],
binary: false,
generated: false,
non_text: None,
}
}
/// A review whose first file is accounted for by *evidence* (nobody attributed it to the agent) and
/// whose last file is nothing but mechanical churn — the two shapes that used to render nothing.
fn review_of(files: Vec<ReviewFile>) -> GuidedReview {
let items: Vec<ReviewItemRef> = files
.iter()
.flat_map(|file| file.hunks.iter().map(|hunk| ReviewItemRef::Hunk(hunk.id.clone())))
.collect();
let revision_id = ReviewRevisionId::from_canonical_bytes(b"never blank");
GuidedReview {
conversation: None,
id: ReviewId::new(),
revision_id: revision_id.clone(),
target: ReviewTarget::WorkingTree,
source: ReviewSource {
base: ReviewBase::EmptyTree,
content_digest: revision_id,
includes_staged: false,
includes_unstaged: false,
included_untracked_files: 0,
captured_at_ms: 0,
uncovered_paths: Vec::new(),
},
context: ReviewContext {
title: "Never blank".into(),
goal: None,
phase_index: None,
phase_title: None,
planning_excerpt: None,
acceptance_excerpt: None,
source_intent: None,
source_commits: 0,
pull_request: None,
},
stats: ReviewStats {
files: files.len() as u64,
hunks: items.len() as u64,
additions: Some(files.len() as u64),
deletions: Some(0),
binary_files: 0,
non_text_files: 0,
excluded_files: 0,
},
files,
chapters: vec![ReviewChapter {
id: ChapterId::from_items("core", &[]),
title: "Everything".into(),
rationale: "One chapter over the whole change.".into(),
impact: None,
kind: ChapterKind::Core,
items,
notes: Vec::new(),
}],
checks: CheckSummary::default(),
// The agent wrote exactly one of these files; the rest still need review.
provenance: Some(TurnProvenance {
written_paths: ["src/agent.rs".to_owned()].into_iter().collect(),
..Default::default()
}),
insight: None,
seen: None,
brief: None,
generated_at_ms: 0,
}
}
fn opened(review: GuidedReview) -> App {
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.current_view = ViewMode::GuidedReview;
let request_id = ReviewLoadRequestId::new();
app.active_guided_review_request = Some(request_id.clone());
app.update(Msg::Engine(Event::GuidedReviewLoaded { request_id, review: Box::new(review) }));
app.update(Msg::TerminalResized { width: WIDTH, height: HEIGHT });
app
}
/// Everything the content pane drew, to the right of the rail.
/// The whole frame, rail included — for facts the review states beside the document rather than
/// inside it.
fn frame(app: &mut App) -> String {
let mut terminal = Terminal::new(TestBackend::new(WIDTH, HEIGHT)).unwrap();
terminal.draw(|frame| render(frame, app)).unwrap();
terminal.backend().buffer().content.iter().map(ratatui::buffer::Cell::symbol).collect()
}
fn content(app: &mut App) -> String {
let mut terminal = Terminal::new(TestBackend::new(WIDTH, HEIGHT)).unwrap();
terminal.draw(|frame| render(frame, app)).unwrap();
let buffer = terminal.backend().buffer().clone();
let rail = luxe_tui::workspace_layout::LEFT_RAIL_WIDTH;
let mut out = String::new();
for y in 0..HEIGHT {
for x in rail..WIDTH {
out.push_str(buffer.cell((x, y)).unwrap().symbol());
}
out.push('\n');
}
out
}
/// A hunk nothing but *evidence* accounts for is code. It renders.
#[test]
fn evidence_based_accounting_never_hides_a_line_of_code() {
let review = review_of(vec![
text_file("src/vendored.rs", NoiseKind::Semantic, "vendored"),
text_file("src/agent.rs", NoiseKind::Semantic, "agent"),
]);
let mut app = opened(review);
let pane = content(&mut app);
assert!(
pane.contains("let vendored_answer = 42;"),
"the review opened on a file it accounts for and drew nothing: {pane}"
);
assert!(pane.contains("@@ -1,2 +1,3 @@ vendored"), "its hunk header is there too: {pane}");
}
/// A file of nothing but mechanical churn is a collapsed row that says so, never an empty pane.
#[test]
fn a_fully_collapsed_file_renders_a_row_that_says_what_it_stands_for() {
let review = review_of(vec![
text_file("Cargo.lock", NoiseKind::Lockfile, "dependencies"),
text_file("src/agent.rs", NoiseKind::Semantic, "agent"),
]);
let mut app = opened(review.clone());
let lockfile = review.files[0].id.clone();
app.update(Msg::GuidedReviewSelectFile(lockfile.clone()));
let collapsed = content(&mut app);
assert!(
collapsed.contains("1 change · 2 lines · lockfile"),
"the collapsed run names what it stands for: {collapsed}"
);
assert!(
!collapsed.contains("let dependencies_answer = 42;"),
"and it is still collapsed: {collapsed}"
);
// Opening it is one keystroke, and it opens only this file.
app.update(Msg::GuidedReviewToggleFileFold(lockfile));
let open = content(&mut app);
assert!(open.contains("let dependencies_answer = 42;"), "opening the run reads it: {open}");
}
/// The walkthrough visits a file made entirely of churn instead of stepping silently past it.
#[test]
fn the_walkthrough_stops_on_a_collapsed_file_rather_than_skipping_it() {
let review = review_of(vec![
text_file("src/agent.rs", NoiseKind::Semantic, "agent"),
text_file("Cargo.lock", NoiseKind::Lockfile, "dependencies"),
]);
let mut app = opened(review);
app.update(Msg::GuidedReviewHunkNext);
let pane = content(&mut app);
assert!(pane.contains("Cargo.lock"), "stepping forward reaches the collapsed file: {pane}");
assert!(pane.contains("1 change · 2 lines · lockfile"), "and it shows what is there: {pane}");
}
/// Whatever the cursor is on, the pane has content on it.
#[test]
fn no_reachable_cursor_position_renders_an_empty_pane() {
let review = review_of(vec![
text_file("Cargo.lock", NoiseKind::Lockfile, "dependencies"),
text_file("src/vendored.rs", NoiseKind::Semantic, "vendored"),
text_file("src/agent.rs", NoiseKind::Semantic, "agent"),
]);
let mut app = opened(review);
for step in 0..12 {
let pane = content(&mut app);
// The first three rows are the narration band and its rule; the diff starts under them.
let body: String = pane.lines().skip(4).collect::<Vec<_>>().join("\n");
assert!(!body.trim().is_empty(), "step {step} left the diff pane empty:\n{pane}");
app.update(Msg::GuidedReviewLineNext);
}
}
/// Prints the collapsed-run shape so it can be reviewed as text, without a screenshot.
#[test]
#[ignore = "shape snapshot, run explicitly"]
fn collapsed_run_shape_snapshot() {
let review = review_of(vec![
text_file("src/agent.rs", NoiseKind::Semantic, "agent"),
text_file("Cargo.lock", NoiseKind::Lockfile, "dependencies"),
]);
let mut app = opened(review.clone());
app.update(Msg::GuidedReviewToggleSplit);
app.update(Msg::GuidedReviewSelectFile(review.files[1].id.clone()));
println!("{}", content(&mut app));
}
/// Prints the map so its shape can be reviewed as text.
#[test]
#[ignore = "shape snapshot, run explicitly"]
fn overview_shape_snapshot() {
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewLarge).unwrap();
app.update(Msg::TerminalResized { width: WIDTH, height: HEIGHT });
println!("{}", content(&mut app));
}
/// A binary in the change used to make the whole review's line totals unknown.
#[test]
fn one_uncountable_file_does_not_erase_the_review_s_line_totals() {
use luxe_core::guided_review::{NonTextChange, NonTextChangeKind};
let mut binary = text_file("logo.png", NoiseKind::Semantic, "binary");
binary.hunks.clear();
binary.additions = None;
binary.deletions = None;
binary.binary = true;
binary.non_text =
Some(NonTextChange { kind: NonTextChangeKind::Binary, summary: "Binary change".into() });
let files = vec![text_file("src/agent.rs", NoiseKind::Semantic, "agent"), binary];
let stats = ReviewStats::from_files(&files);
assert_eq!(stats.additions, Some(1), "the text file's lines are still countable");
assert_eq!(stats.deletions, Some(0));
assert_eq!(stats.non_text_files, 1, "and the binary is reported as what it is");
}
/// A new file has no old side; two columns for it means half the pane is an empty tinted block.
#[test]
fn a_one_sided_file_reads_unified_even_when_the_session_prefers_split() {
let mut added = text_file("src/added.rs", NoiseKind::Semantic, "added");
added.status = ReviewFileStatus::Added;
added.hunks[0].lines.retain(|line| line.kind != ReviewLineKind::Context);
let modified = text_file("src/agent.rs", NoiseKind::Semantic, "agent");
let review = review_of(vec![added, modified]);
let mut app = opened(review.clone());
app.update(Msg::GuidedReviewToggleSplit);
// The modified file has both sides, so it keeps the two columns and their divider.
app.update(Msg::GuidedReviewSelectFile(review.files[1].id.clone()));
assert!(content(&mut app).contains('│'), "a two-sided file still renders side by side");
app.update(Msg::GuidedReviewSelectFile(review.files[0].id.clone()));
let one_sided = content(&mut app);
assert!(
one_sided.contains("let added_answer = 42;"),
"the added line is on screen: {one_sided}"
);
let widest = one_sided
.lines()
.filter(|line| line.contains("let added_answer"))
.map(|line| line.trim_end().chars().count())
.max()
.unwrap_or_default();
assert!(widest < 60, "and it is not crammed into half a pane: {one_sided}");
}
/// A review opens at the start of the walkthrough, not at whatever file sorts first.
#[test]
fn a_review_opens_on_the_first_chapter() {
let mut review = review_of(vec![
text_file("AGENTS.md", NoiseKind::Semantic, "docs"),
text_file("src/agent.rs", NoiseKind::Semantic, "agent"),
]);
// Two chapters, and the file that sorts first belongs to the last one.
let docs = ReviewItemRef::Hunk(review.files[0].hunks[0].id.clone());
let core = ReviewItemRef::Hunk(review.files[1].hunks[0].id.clone());
review.chapters = vec![
ReviewChapter {
id: ChapterId::from_items("core", &[]),
title: "The feature".into(),
rationale: "What was asked for.".into(),
impact: None,
kind: ChapterKind::Core,
items: vec![core],
notes: Vec::new(),
},
ReviewChapter {
id: ChapterId::from_items("generated", &[]),
title: "The rest".into(),
rationale: "Everything else.".into(),
impact: None,
kind: ChapterKind::Generated,
items: vec![docs],
notes: Vec::new(),
},
];
let mut app = seeded_app("nord", FixtureScenario::GuidedReviewReady).unwrap();
app.current_view = ViewMode::GuidedReview;
let request_id = ReviewLoadRequestId::new();
app.active_guided_review_request = Some(request_id.clone());
app.update(Msg::Engine(Event::GuidedReviewLoaded { request_id, review: Box::new(review) }));
app.update(Msg::TerminalResized { width: WIDTH, height: HEIGHT });
let rendered = frame(&mut app);
assert!(rendered.contains("01 / 02"), "the walkthrough starts at its start: {rendered}");
assert!(rendered.contains("The feature"), "on the chapter the guide put first: {rendered}");
assert!(rendered.contains("src/agent.rs"), "and on that chapter's file: {rendered}");
}
/// What a review leaves out, it says out loud.
#[test]
fn excluded_files_are_counted_not_silently_dropped() {
let mut review = review_of(vec![text_file("src/agent.rs", NoiseKind::Semantic, "agent")]);
review.stats.excluded_files = 3;
let mut app = opened(review);
let rendered = frame(&mut app);
assert!(
rendered.contains("3 files excluded by review.exclude"),
"the review admits it is not the whole diff: {rendered}"
);
}
/// What a preview's surface draws at `width` × `height`, as text.
fn drawn(scenario: FixtureScenario, width: u16, height: u16) -> String {
let mut app = seeded_app("nord", scenario).expect("fixture");
app.update(Msg::TerminalResized { width, height });
let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("terminal");
terminal.draw(|frame| render(frame, &mut app)).expect("drawn without a panic");
terminal.backend().buffer().content.iter().map(|cell| cell.symbol()).collect()
}
/// Every review preview survives a short or narrow screen, opened there or resized into it: where
/// it cannot fit it says so, and from there up it draws inside the screen with its way out.
///
/// The break this catches: the previews sized themselves with `clamp(minimum, height - 2)`, which
/// panics, even in a release build, the moment the screen is shorter than the minimum plus two.
#[test]
fn review_previews_survive_a_short_terminal() {
let previews = [
(FixtureScenario::GuidedReviewPullRequestPost, 10),
(FixtureScenario::GuidedReviewFixPullRequest, 9),
(FixtureScenario::GuidedReviewOpenStack, 10),
(FixtureScenario::GuidedReviewOwnPullRequest, 12),
];
for (scenario, threshold) in previews {
let tiny = drawn(scenario, 40, 5);
assert!(tiny.contains("Make the window bigger"), "{scenario:?} at 40×5: {tiny}");
for height in [threshold - 1, threshold, 40] {
for width in [40, 49, 120] {
let shown = drawn(scenario, width, height);
// drawn, not the notice, whose own text also names esc
let drawn = !shown.contains("Make the window bigger") && shown.contains("esc");
assert!(drawn, "{scenario:?} at {width}×{height}: {shown}");
}
}
// opened on a normal screen, then shrunk under it
let mut app = seeded_app("nord", scenario).expect("fixture");
let mut terminal = Terminal::new(TestBackend::new(120, 40)).expect("terminal");
terminal.draw(|frame| render(frame, &mut app)).expect("drawn");
for height in [threshold - 1, 5] {
terminal.backend_mut().resize(40, height);
app.update(Msg::TerminalResized { width: 40, height });
terminal.autoresize().expect("resized");
terminal.draw(|frame| render(frame, &mut app)).expect("redrawn without a panic");
let shown: String =
terminal.backend().buffer().content.iter().map(|cell| cell.symbol()).collect();
let notice = shown.contains("Make the window bigger");
assert_eq!(notice, height == 5, "{scenario:?} shrunk to {height}: {shown}");
}
}
// the one preview that always fitted still offers its way out at the smallest size
let smallest = drawn(FixtureScenario::GuidedReviewOpenPullRequest, 40, 5);
assert!(smallest.contains("esc") && !smallest.contains("Make the window bigger"), "{smallest}");
}

View File

@@ -0,0 +1,176 @@
//! A folded run must not move the transcript, and must not strobe while it works.
//!
//! Both defects came from deciding what a run was by looking at the cards already on screen. Three
//! lookups landed as three cards and the third folded the two above it, so the conversation dropped
//! four rows under whoever was reading it; and the folded line asked "is a call running right now",
//! which is false in the gap between two of them, so its band flashed green once per call. The run
//! is a fact about the message that asked for it, and both tests here read as one consequence.
use luxe_core::config::{Config, ConversationConfig, ToolRuns};
use luxe_core::keymap::KeyMap;
use luxe_core::message::ContentBlock;
use luxe_core::{ToolActivity, ToolActivityState};
use luxe_tui::app::{App, ConvoBlock, ToolItem};
use luxe_tui::view::render;
use ratatui::backend::TestBackend;
use ratatui::buffer::Buffer;
use ratatui::Terminal;
const WIDTH: u16 = 100;
const HEIGHT: u16 = 30;
/// Where the transcript is watched from: a line of the reader's own, above the run.
const MARKER: &str = "MARKERUSER";
fn app_with(tool_runs: Option<ToolRuns>) -> App {
let (tx, _rx) = tokio::sync::mpsc::channel::<luxe_core::engine::Action>(64);
let config = Config {
conversation: ConversationConfig { tool_runs, ..Default::default() },
..Default::default()
};
App::new(tx, KeyMap::defaults(), config)
}
fn draw(app: &mut App, backend: &TestBackend) -> Buffer {
let mut terminal = Terminal::new(backend.clone()).unwrap();
terminal.draw(|f| render(f, app)).unwrap();
terminal.backend().buffer().clone()
}
fn row_text(buffer: &Buffer, y: u16) -> String {
(0..WIDTH).map(|x| buffer[(x, y)].symbol()).collect()
}
/// The screen row the reader's own line is on, which is the thing that must not move.
fn marker_row(buffer: &Buffer) -> Option<u16> {
(0..HEIGHT).find(|y| row_text(buffer, *y).contains(MARKER))
}
/// The wash behind the folded run's line.
fn run_band(buffer: &Buffer) -> Option<ratatui::style::Color> {
(0..HEIGHT).find(|y| row_text(buffer, *y).contains("read")).map(|y| buffer[(4, y)].bg)
}
/// One message's worth of `read` calls, built the way the runtime builds them.
fn reads(count: u32) -> Vec<ToolActivity> {
let content = (1..=count)
.map(|n| ContentBlock::ToolCall {
id: format!("call-{n}"),
name: "read".into(),
arguments: serde_json::json!({ "path": format!("file-{n}.rs") }),
})
.collect::<Vec<_>>();
let runs = luxe_core::lookup_runs(&content);
content
.iter()
.map(|block| {
let ContentBlock::ToolCall { id, name, arguments } = block else {
unreachable!("built from tool calls");
};
let label = luxe_core::describe_call(name, arguments, "/project");
let mut activity = ToolActivity::running("s", id, name, label, 1);
activity.input_preview = Some(arguments.to_string());
activity.run = runs.get(id).copied();
activity
})
.collect()
}
fn push(app: &mut App, activity: ToolActivity) {
app.push_convo(ConvoBlock::Tool(Box::new(ToolItem {
activity,
expanded: false,
details_toggled: false,
waited_on_user_ms: 0,
})));
}
/// Marks the last card the way the call ending does.
fn finish(app: &mut App) {
let last = app.convo.len() - 1;
if let ConvoBlock::Tool(tool) = app.convo[last].block_mut() {
tool.activity.state = ToolActivityState::Succeeded;
tool.activity.summary = Some("Completed".into());
tool.activity.elapsed_ms = Some(40);
tool.activity.output_preview = Some("some output".into());
}
}
/// Nothing above a run may move while the run happens.
///
/// The transcript is anchored to the bottom, so every row a fold reclaims is a row everything above
/// it drops by. Measured before the fix: four rows, in one frame, on the third card.
#[test]
fn a_run_never_moves_the_transcript_above_it() {
let backend = TestBackend::new(WIDTH, HEIGHT);
let mut app = app_with(None);
app.push_convo(ConvoBlock::User {
text: format!("{MARKER} find the thing"),
attached: Vec::new(),
chips: Vec::new(),
});
app.push_convo(ConvoBlock::Assistant("Let me look at the code.".into()));
let mut rows = Vec::new();
for activity in reads(7) {
push(&mut app, activity);
rows.push(marker_row(&draw(&mut app, &backend)));
finish(&mut app);
rows.push(marker_row(&draw(&mut app, &backend)));
}
let settled = rows[0];
assert!(settled.is_some(), "the reader's own line has to be on screen to be watched");
assert!(
rows.iter().all(|row| *row == settled),
"the transcript moved under the reader while the run ran: {rows:?}"
);
}
/// A run that is still going keeps one band the whole way down.
///
/// Dispatch is sequential, so between one call ending and the next starting nothing is running —
/// which is not the same as finished. Reading it as finished washed the line green and back on
/// every call boundary: several flashes a second on the line whose job is to be the calm one.
#[test]
fn a_working_run_keeps_one_band() {
let backend = TestBackend::new(WIDTH, HEIGHT);
let mut app = app_with(None);
let calls = reads(7);
let last = calls.len() - 1;
let mut bands = Vec::new();
for (index, activity) in calls.into_iter().enumerate() {
push(&mut app, activity);
bands.push(run_band(&draw(&mut app, &backend)));
finish(&mut app);
// The last call settling settles the run, which has earned a different band.
if index < last {
bands.push(run_band(&draw(&mut app, &backend)));
}
}
let working = bands[0];
assert!(working.is_some(), "the folded run has to be on screen");
assert!(
bands.iter().all(|band| *band == working),
"the run's band flickered while it worked: {bands:?}"
);
let done = run_band(&draw(&mut app, &backend));
assert_ne!(done, working, "and a finished run stops wearing the working band");
}
/// Asking for cards gets cards, however many the message asked for.
#[test]
fn tool_runs_cards_draws_every_lookup() {
let backend = TestBackend::new(WIDTH, HEIGHT);
let mut app = app_with(Some(ToolRuns::Cards));
for activity in reads(4) {
push(&mut app, activity);
finish(&mut app);
}
let buffer = draw(&mut app, &backend);
let text = (0..HEIGHT).map(|y| row_text(&buffer, y)).collect::<Vec<_>>().join("\n");
assert!(text.contains("file-4.rs"), "every call keeps its own card: {text}");
assert!(!text.contains("read calls"), "and none of them was folded away: {text}");
}