Files
luxe/crates/luxe-tui/src/app/tests/status.rs

354 lines
14 KiB
Rust
Raw Normal View History

//! Status — the status model, usage, the clock and the prompts that stop it.
use super::*;
/// A full turn (stream → commit → turn end) leaves the status line Idle, not Streaming.
#[tokio::test]
async fn test_turn_end_returns_to_idle() {
let (tx, _rx) = mpsc::channel(8);
let keymap = luxe_core::keymap::KeyMap::defaults();
let config = luxe_core::config::Config::default();
let mut app = App::new(tx, keymap, config);
app.update(Msg::Engine(Event::TokenDelta { block: 0, delta: "hi".into() }));
assert!(matches!(app.status.state, AppState::Streaming));
let committed = luxe_core::message::Message::assistant("hi");
app.update(Msg::Engine(Event::MessageCommitted {
session_id: "test-session".into(),
entry_id: luxe_core::session::EntryId("entry-1".into()),
message: committed,
}));
app.update(Msg::Engine(Event::TurnEnded { reason: luxe_core::event::StopReason::EndTurn }));
assert!(
matches!(app.status.state, AppState::Idle),
"status must return to Idle once the turn ends"
);
}
/// A `ContextUsage` event fills in the status-line context percentage.
#[tokio::test]
async fn test_context_usage_sets_percent() {
let (tx, _rx) = mpsc::channel(8);
let keymap = luxe_core::keymap::KeyMap::defaults();
let config = luxe_core::config::Config::default();
let mut app = App::new(tx, keymap, config);
app.update(Msg::Engine(Event::ContextUsage { used_tokens: 8_240, context_window: 128_000 }));
assert!(
(app.status.context_pct - 6.4375).abs() < 0.01,
"context_pct should be ~6.44%, got {}",
app.status.context_pct
);
assert_eq!(app.status.context_window, 128_000);
}
#[tokio::test]
async fn state_change_updates_model_and_thinking() {
let (tx, _rx) = mpsc::channel(8);
let mut app =
App::new(tx, luxe_core::keymap::KeyMap::defaults(), luxe_core::config::Config::default());
app.update(Msg::Engine(Event::StateChanged(luxe_core::event::EngineState {
model: luxe_core::event::ModelRef::new("anthropic", "claude-sonnet"),
streaming: false,
status: "mode: plan".into(),
mode: luxe_core::mode::PLAN.into(),
thinking: luxe_core::provider::ThinkingLevel::High,
})));
assert_eq!(app.status.model, "claude-sonnet");
assert_eq!(app.status.thinking, luxe_core::provider::ThinkingLevel::High);
}
#[test]
fn test_status_model_spinner_advances() {
let mut status = StatusModel { state: AppState::Streaming, ..Default::default() };
assert_eq!(status.spinner_frame, 0);
status.tick(false);
assert_eq!(status.spinner_frame, 1);
status.tick(false);
assert_eq!(status.spinner_frame, 2);
// Idle, it holds still unless a panel is waiting on something
let mut idle = StatusModel::default();
idle.tick(false);
assert_eq!(idle.spinner_frame, 0);
idle.tick(true);
assert_eq!(idle.spinner_frame, 1);
}
/// The timer measures against the instant it is handed, not the wall.
///
/// It used to sleep 10 ms and assert the wall had moved, which passes whichever clock the timer
/// reads — so it sat green through every recorded demo printing `0.0s`. Handing it an instant the
/// test chose is the version that can fail.
#[test]
fn test_status_model_elapsed_starts_stops() {
let mut status = StatusModel::default();
let now = std::time::Instant::now();
assert!(status.elapsed(now).is_none(), "no elapsed when idle");
status.on_turn_start();
let started = status.turn_started.expect("a turn is under way");
let four_seconds_on = started + std::time::Duration::from_secs(4);
assert_eq!(
status.elapsed(four_seconds_on),
Some(std::time::Duration::from_secs(4)),
"the timer reported its own clock rather than the one it was given"
);
// A pinned clock can sit behind the start it was pinned against; that is 0, not a panic.
assert_eq!(
status.elapsed(started - std::time::Duration::from_secs(1)),
Some(std::time::Duration::ZERO)
);
status.turn_started = None;
assert!(status.elapsed(now).is_none(), "elapsed must be None after turn ends");
}
/// An answer the engine could not be handed keeps its prompt open, because a prompt that closed
/// over a lost answer left the turn blocked behind nothing anyone could press.
#[tokio::test]
async fn an_answer_that_could_not_be_delivered_keeps_its_prompt() {
let (tx, mut rx) = mpsc::channel(1);
let mut app = app_running_a_call(tx.clone());
let base = std::time::Instant::now();
app.status.frame_clock = Some(base);
app.update(Msg::Engine(Event::PermissionRequested {
id: serde_json::from_value(serde_json::json!("perm:1")).expect("an id"),
session_id: "session-a".into(),
tool: "git".into(),
permission: "git".into(),
summary: "git commit — more".into(),
always_patterns: Vec::new(),
}));
// The channel is full, the way a stalled engine leaves it
tx.try_send(luxe_core::engine::Action::RefreshSessions).expect("room for one");
app.update(Msg::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)));
assert!(app.overlays.permission.is_some(), "the answer did not go, so the prompt stays");
// Room again: the same key answers it
let _ = rx.try_recv();
app.update(Msg::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)));
assert!(app.overlays.permission.is_none());
assert!(matches!(
rx.try_recv(),
Ok(luxe_core::engine::Action::RespondPermission {
reply: luxe_core::permission::PermissionReply::Reject,
..
})
));
}
/// The wait is reconciled from what is on screen, so every way a prompt closes stops the clock.
///
/// A prompt opens on an event and closes on a keystroke, on an interrupt, or with the turn — four
/// paths, and a reducer that banked the time on only some of them would leave the clock stopped
/// for the rest of the session.
#[tokio::test]
async fn a_prompt_on_screen_stops_the_clock_and_the_card_discounts_it() {
let (tx, _rx) = mpsc::channel(8);
let mut app = App::new(tx, KeyMap::defaults(), Config::default());
app.update(Msg::Engine(Event::SessionLoaded {
session_id: "session-a".into(),
messages: Vec::new(),
}));
app.update(Msg::Engine(Event::ToolStarted { call_id: "call-1".into(), name: "bash".into() }));
app.update(Msg::Engine(Event::ToolActivityUpdated(Box::new(ToolActivity::running(
"session-a",
"call-1",
"bash",
"rm -rf build",
1,
)))));
// Anchored on the turn's own start, which `on_turn_start` reads off the wall clock.
let base = app.status.turn_started.expect("a turn is under way");
let at = |secs: u64| base + std::time::Duration::from_secs(secs);
app.status.frame_clock = Some(base);
app.status.frame_clock = Some(at(1));
app.update(Msg::Engine(Event::PermissionRequested {
id: serde_json::from_value(serde_json::json!("perm:1")).expect("an id"),
session_id: "session-a".into(),
tool: "bash".into(),
permission: "bash".into(),
summary: "Run: rm -rf build".into(),
always_patterns: Vec::new(),
}));
assert!(app.overlays.permission.is_some());
// Nothing accrues while the reader is looking at it.
app.status.frame_clock = Some(at(21));
app.update(Msg::Tick);
assert_eq!(app.status.elapsed(at(21)).expect("a turn").as_secs(), 1);
// Answered at twenty-one seconds, the way the modal actually closes.
app.update(Msg::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)));
assert!(app.overlays.permission.is_none(), "the prompt is answered and gone");
assert_eq!(app.status.user_wait(at(21)).as_secs(), 20);
// And the agent's own time picks up from the second it had before the prompt.
app.status.frame_clock = Some(at(23));
app.update(Msg::Tick);
assert_eq!(app.status.elapsed(at(23)).expect("a turn").as_secs(), 3);
// And the card that was blocked discounts it rather than reporting it as the tool's own time.
let blocked = app
.tool_items
.values()
.find(|item| item.activity.call_id == "call-1")
.expect("the card the prompt was gating");
assert_eq!(blocked.waited_on_user_ms / 1000, 20);
assert!(
matches!(
app.convo.first().map(ConversationItem::block),
Some(ConvoBlock::Tool(item)) if item.waited_on_user_ms / 1000 == 20
),
"the transcript's own copy of the card carries it too"
);
}
/// The timer reports how long the *agent* has been working, so it stops while a person decides.
///
/// A turn blocked on a permission prompt or the `question` tool is not a turn working, and the
/// figure beside `Ctrl+Esc to interrupt` is read as how long the agent has been at it. Left
/// running it reports the reader's own deliberation back to them.
#[test]
fn the_turn_timer_stops_while_a_person_is_deciding() {
let mut status = StatusModel::default();
status.on_turn_start();
let started = status.turn_started.expect("a turn is under way");
let at = |secs| started + std::time::Duration::from_secs(secs);
let elapsed = |status: &StatusModel, secs| {
status.elapsed(at(secs)).expect("a turn is under way").as_secs()
};
assert_eq!(elapsed(&status, 2), 2);
// A prompt opens at two seconds and the clock stops where it was, however long it stays up.
status.waiting_on_user(true, at(2));
assert_eq!(elapsed(&status, 5), 2, "a wait still open does not accrue");
assert_eq!(elapsed(&status, 30), 2);
// Answered at thirty-two; the agent's time picks up from the two it had.
assert_eq!(
status.waiting_on_user(false, at(32)).map(|waited| waited.as_secs()),
Some(30),
"the wait it banked is what the card it blocked has to discount",
);
assert_eq!(elapsed(&status, 33), 3);
assert_eq!(status.user_wait(at(33)).as_secs(), 30);
// A second wait banks on top of the first rather than replacing it.
status.waiting_on_user(true, at(33));
status.waiting_on_user(false, at(43));
assert_eq!(elapsed(&status, 44), 4);
assert_eq!(status.user_wait(at(44)).as_secs(), 40);
// Redundant reconciliations are no-ops — it is called after every message, not per prompt.
assert!(status.waiting_on_user(false, at(45)).is_none());
status.waiting_on_user(true, at(45));
assert!(status.waiting_on_user(true, at(46)).is_none());
// And a fresh turn owes nothing to the last one's waits.
status.on_turn_start();
let restarted = status.turn_started.expect("a turn is under way");
assert_eq!(
status.elapsed(restarted + std::time::Duration::from_secs(1)),
Some(std::time::Duration::from_secs(1))
);
}
/// A turn's usage events are **per provider call**, so the per-turn figures sum them.
///
/// They used to overwrite, on the theory that each event restated a running total. It does not: a
/// turn that runs twenty tools makes twenty independent calls, and treating the last one as the
/// whole turn is how a session's spend came to be understated several-fold.
#[test]
fn per_turn_figures_sum_every_call_in_the_turn() {
let mut status = StatusModel::default();
assert_eq!(status.prompt_tokens, 0);
assert_eq!(status.completion_tokens, 0);
assert!(status.cost_usd.is_none());
status.on_call_usage(100, 50, 800, Some(0.001));
assert_eq!(status.prompt_tokens, 100);
assert_eq!(status.completion_tokens, 50);
assert_eq!(status.cache_read_tokens, 800);
assert_eq!(status.cost_usd, Some(0.001));
status.on_call_usage(120, 60, 200, Some(0.002));
assert_eq!(status.prompt_tokens, 220, "a second call adds to the turn");
assert_eq!(status.completion_tokens, 110);
assert_eq!(status.cache_read_tokens, 1_000);
assert_eq!(status.cost_usd, Some(0.003));
status.on_turn_start();
assert_eq!(status.prompt_tokens, 0, "a new turn starts its own per-turn figures");
assert_eq!(status.cost_usd, None);
}
/// The session figures are the engine's, rendered verbatim — the UI performs no accounting.
#[test]
fn session_totals_are_adopted_from_the_engine_not_derived() {
use luxe_core::usage::{SessionUsage, SourceUsage, UsageSource, UsageTotals};
let mut status = StatusModel::default();
assert_eq!(status.session_cost_label(), None, "nothing spent yet, nothing claimed");
let agent = UsageTotals {
calls: 47,
prompt_tokens: 1_270_000,
completion_tokens: 11_900,
cost_usd: 0.4381,
..Default::default()
};
status.on_session_usage(SessionUsage {
total: agent,
by_source: vec![SourceUsage { source: UsageSource::Agent, totals: agent }],
});
assert_eq!(status.session.total.calls, 47);
assert_eq!(status.session_cost_label().as_deref(), Some("$0.44"), "rounded to the cent");
// A later snapshot replaces the previous one rather than adding to it.
let grown = UsageTotals { cost_usd: 0.61, ..agent };
status.on_session_usage(SessionUsage {
total: grown,
by_source: vec![SourceUsage { source: UsageSource::Agent, totals: grown }],
});
assert_eq!(status.session_cost_label().as_deref(), Some("$0.61"));
status.reset_session_cost();
assert_eq!(status.session_cost_label(), None, "loading another session starts a fresh tally");
}
#[test]
fn test_status_model_cost_none_when_price_unknown() {
let mut status = StatusModel::default();
// Default model has cost.input = 0.0, so cost should be None.
status.on_call_usage(100, 50, 0, None);
assert_eq!(status.cost_usd, None);
}
#[test]
fn test_status_model_format_elapsed() {
// Zero duration.
let formatted = StatusModel::format_elapsed(std::time::Duration::ZERO);
assert!(formatted.contains("0s"), "zero elapsed should show 0s");
// Whole seconds. This counts up on a running turn, so a tenths digit is a number moving ten
// times a second beside a spinner already saying the same thing.
assert_eq!(StatusModel::format_elapsed(std::time::Duration::from_millis(3_140)), "3s");
assert_eq!(StatusModel::format_elapsed(std::time::Duration::from_secs(83)), "1m 23s");
}
#[test]
fn test_status_model_format_cost() {
assert_eq!(StatusModel::format_cost(None), String::new(), "None cost formats to empty");
assert_eq!(StatusModel::format_cost(Some(0.42)), "$0.42");
// Under half a cent there is nothing to round to, and "$0.00" would report real work as free.
assert_eq!(StatusModel::format_cost(Some(0.004)), "<$0.01");
}
pub(super) fn type_into(app: &mut App, text: &str) {
for character in text.chars() {
app.update(Msg::Key(KeyEvent::new(KeyCode::Char(character), KeyModifiers::NONE)));
}
}