public/galaxy
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
5a79ed0aa7258bf51f5fe75015ac8c009ef9b3bb
galaxy/app/src/terminal/view_test.rs
T

4608 lines
172 KiB
Rust
Raw Blame History

use std::cell::RefCell;
use std::pin::pin;
use std::rc::Rc;
use crate::ai::agent::conversation::ConversationStatus;
use galaxy_terminal::model::escape_sequences::{BRACKETED_PASTE_END, BRACKETED_PASTE_START};
use galaxyui::{notification::UserNotification, Presenter, WindowInvalidation};
use crate::ai::agent::task::TaskId;
use crate::ai::blocklist::block::cli_controller::UserTakeOverReason;
use galaxyui::App;
use crate::pane_group::focus_state::PaneGroupFocusState;
use crate::pane_group::{BackingView, TerminalPaneId};
use crate::terminal::model::grid::Dimensions as _;
use crate::{
terminal::alt_screen::should_intercept_mouse,
test_util::terminal::add_window_with_id_and_terminal,
};
use crate::context_chips::prompt::Prompt;
use crate::editor::{AutosuggestionLocation, AutosuggestionType};
use crate::settings::{AISettings, AppEditorSettings, WarpPromptSeparator};
use crate::ai::blocklist::agent_view::toolbar_item::AgentToolbarItemKind;
use crate::ai::blocklist::{
agent_view::AgentViewEntryOrigin, BlocklistAIHistoryModel, InputConfig, InputType,
};
use crate::features::FeatureFlag;
use crate::terminal::cli_agent_sessions::event::{
CLIAgentEvent, CLIAgentEventPayload, CLIAgentEventType,
};
use crate::terminal::cli_agent_sessions::listener::CLIAgentSessionListener;
use crate::terminal::cli_agent_sessions::{
CLIAgentInputEntrypoint, CLIAgentInputState, CLIAgentRichInputCloseReason, CLIAgentSession,
CLIAgentSessionContext, CLIAgentSessionStatus, CLIAgentSessionsModel,
};
use crate::terminal::CLIAgent;
use crate::terminal::block_list_element::{SnackbarPoint, SnackbarTranslationMode};
use crate::terminal::block_list_viewport::{ClampingMode, ScrollLines};
use crate::terminal::session_settings::AgentToolbarChipSelection;
use crate::view_components::find::FindWithinBlockState;
use crate::terminal::model::ansi::{self, InitShellValue};
use crate::terminal::model::ansi::{BootstrappedValue, PreexecValue};
use crate::terminal::model::blocks::{insert_block, TotalIndex};
use crate::terminal::model::terminal_model::WithinBlock;
use crate::terminal::MockTerminalManager;
use crate::test_util::terminal::initialize_app_for_terminal_view;
use crate::test_util::{add_window_with_terminal, assert_eventually};
use super::*;
/// Test to verify that blocks created through normal execution
/// have the correct local status set
#[test]
fn test_create_new_block_with_local_status() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Set up a terminal with a local session
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
// Initialize a local session
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "bash".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "bash".to_owned(),
..Default::default()
});
});
assert_eventually!(
terminal.read(&app, |view, ctx| !view
.active_block_is_considered_remote(ctx)),
"Block should be local"
);
// No remote blocks should exist
assert_eventually!(
terminal.read(&app, |view, _ctx| !view.contains_restored_remote_blocks()),
"No remote blocks should exist"
);
// Update the view's flags
// view.update_focused_terminal_info(ctx);
assert_eventually!(
terminal.read(&app, |view, _ctx| !view.any_session_contains_remote_blocks),
"No remote blocks should exist"
);
// Now test with a remote session
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
// Create a new block with a remote session ID and remote_shell
model.init_shell(InitShellValue {
session_id: 1.into(),
shell: "bash".to_owned(),
user: "user".to_owned(),
hostname: "remote".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "bash".to_owned(),
..Default::default()
});
// Create a block in the remote session
model.simulate_block("echo remote", "remote output");
});
// Verify block is non-local (remote)
assert_eventually!(
terminal.read(&app, |view, ctx| view
.active_block_is_considered_remote(ctx)),
"Block should be non-local (remote)"
);
// Remote blocks should be detected
assert_eventually!(
terminal.read(&app, |view, _ctx| view.any_session_contains_remote_blocks),
"Remote blocks should be detected"
);
})
}
#[test]
fn submit_cli_agent_rich_input_restores_unlocked_input_config() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_agent_rich_input = FeatureFlag::CLIAgentRichInput.override_enabled(true);
AISettings::handle(&app).update(&mut app, |settings, ctx| {
let _ = settings
.auto_dismiss_rich_input_after_submit
.set_value(true, ctx);
});
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.input.update(ctx, |input, ctx| {
input.ai_input_model().update(ctx, |ai_input, ctx| {
ai_input.set_input_config(
InputConfig {
input_type: InputType::Shell,
is_locked: false,
},
true,
ctx,
);
});
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Droid,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: false,
listener: None,
remote_host: None,
plugin_version: None,
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
view.submit_cli_agent_rich_input("hello!".to_owned(), ctx);
assert!(!view.has_active_cli_agent_input_session(ctx));
});
terminal.read(&app, |view, ctx| {
let input = view.input.as_ref(ctx);
let ai_input_model = input.ai_input_model().as_ref(ctx);
assert_eq!(
ai_input_model.input_config(),
InputConfig {
input_type: InputType::Shell,
is_locked: false,
}
);
assert!(input.editor().as_ref(ctx).buffer_text(ctx).is_empty());
});
})
}
#[test]
fn unregister_cli_agent_session_restores_unlocked_input_config() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_agent_rich_input = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.input.update(ctx, |input, ctx| {
input.ai_input_model().update(ctx, |ai_input, ctx| {
ai_input.set_input_config(
InputConfig {
input_type: InputType::Shell,
is_locked: false,
},
true,
ctx,
);
});
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: false,
listener: None,
remote_host: None,
plugin_version: None,
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.remove_session(view.view_id, ctx);
});
assert!(!view.has_active_cli_agent_input_session(ctx));
assert!(CLIAgentSessionsModel::as_ref(ctx)
.session(view.view_id)
.is_none());
});
terminal.read(&app, |view, ctx| {
let input = view.input.as_ref(ctx);
let ai_input_model = input.ai_input_model().as_ref(ctx);
assert_eq!(
ai_input_model.input_config(),
InputConfig {
input_type: InputType::Shell,
is_locked: false,
}
);
assert!(input.editor().as_ref(ctx).buffer_text(ctx).is_empty());
});
})
}
#[test]
fn clear_buffer_action_in_fullscreen_agent_view_starts_new_conversation() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
let original_conversation_id = terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
})
});
terminal.update(&mut app, |view, ctx| {
view.handle_action(&TerminalAction::ClearBuffer, ctx);
});
terminal.update(&mut app, |view, ctx| {
let new_conversation_id = view
.agent_view_controller()
.as_ref(ctx)
.agent_view_state()
.active_conversation_id()
.expect("agent view should still be active");
assert_ne!(new_conversation_id, original_conversation_id);
});
})
}
#[test]
fn command_first_word_and_suffix_preserves_leading_whitespace() {
assert_eq!(
command_first_word_and_suffix(" myssh arg"),
Some(("myssh", " arg"))
);
}
#[test]
fn command_first_word_and_suffix_handles_alias_without_args() {
assert_eq!(
command_first_word_and_suffix(" myssh"),
Some(("myssh", ""))
);
}
#[test]
fn root_cloud_mode_pane_sets_root_cloud_mode_context_key() {
use crate::settings::import::model::ImportedConfigModel;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
app.add_singleton_model(ImportedConfigModel::new);
FeatureFlag::AgentView.set_enabled(true);
FeatureFlag::CloudMode.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.read(&app, |view, ctx| {
assert!(!view
.keymap_context(ctx)
.set
.contains(init::ROOT_CLOUD_MODE_PANE_KEY));
});
terminal.update(&mut app, |view, ctx| {
view.ambient_agent_view_model().update(ctx, |model, ctx| {
model.enter_setup(ctx);
});
});
terminal.read(&app, |view, ctx| {
assert!(view
.keymap_context(ctx)
.set
.contains(init::ROOT_CLOUD_MODE_PANE_KEY));
});
terminal.update(&mut app, |view, ctx| {
view.ambient_agent_view_model().update(ctx, |model, _| {
model.set_has_parent_terminal(true);
});
});
terminal.read(&app, |view, ctx| {
assert!(!view
.keymap_context(ctx)
.set
.contains(init::ROOT_CLOUD_MODE_PANE_KEY));
});
});
}
#[test]
fn set_input_mode_agent_does_not_enter_local_agent_from_root_cloud_mode_pane() {
use crate::terminal::shared_session::SharedSessionStatus;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
FeatureFlag::CloudMode.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.ambient_agent_view_model().update(ctx, |model, ctx| {
model.enter_setup(ctx);
});
view.model
.lock()
.set_shared_session_status(SharedSessionStatus::FinishedViewer);
});
terminal.update(&mut app, |view, ctx| {
assert!(!view.agent_view_controller().as_ref(ctx).is_active());
view.handle_action(&TerminalAction::SetInputModeAgent, ctx);
assert!(!view.agent_view_controller().as_ref(ctx).is_active());
});
});
}
/// Test clearing of session flag state when terminal is cleared
#[test]
fn test_clear_session_flag_state() {
use galaxy_terminal::shell::ShellType;
use crate::ai::blocklist::SerializedBlockListItem;
use crate::terminal::model::block::SerializedBlock;
use crate::terminal::ShellHost;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
// Create a remote restored block
let mut remote_block =
SerializedBlock::new_for_test("echo remote".into(), "remote output".into());
remote_block.is_local = Some(false); // Mark it as a remote block
remote_block.shell_host = Some(ShellHost {
shell_type: ShellType::Bash,
user: "user".to_string(),
hostname: "remote".to_string(), // Remote hostname indicates a remote session
});
// Convert to SerializedBlockListItem
let restored_blocks = [SerializedBlockListItem::Command {
block: Box::new(remote_block),
}];
// Create terminal with the restored remote block
let terminal = add_window_with_terminal(&mut app, Some(&restored_blocks));
terminal.update(&mut app, |view, ctx| {
// Verify initial state - block was created as remote and restored
assert!(
!view.any_session_contains_remote_blocks,
"Terminal should not have remote blocks"
);
assert!(
view.any_session_contains_restored_remote_blocks,
"Terminal should have restored remote blocks"
);
{
// Verify the block was properly created with correct properties
let model = view.model.lock();
let blocks = model.block_list().blocks();
// The first block should be our restored remote block
assert!(!blocks.is_empty(), "At least one block should exist");
if let Some(first_block) = blocks.first() {
assert_eq!(
first_block.restored_block_was_local(),
Some(false),
"First block should be marked as a remote restored block"
);
}
}
// Now clear the terminal
view.clear_buffer_for_testing(ctx);
// Flags should be reset
assert!(
!view.any_session_contains_remote_blocks,
"Terminal should not have remote blocks after clearing"
);
assert!(
!view.any_session_contains_restored_remote_blocks,
"Terminal should not have restored remote blocks after clearing"
);
});
})
}
fn assert_block_has_find_match(find_model: &TerminalFindModel, block_index: BlockIndex) {
assert!(find_model
.block_list_find_run()
.is_some_and(|run| run.matches_for_block(block_index).next().is_some()));
}
impl TerminalView {
fn is_top_of_active_block_in_viewport(
&self,
model: &TerminalModel,
input_mode: InputMode,
app: &AppContext,
) -> bool {
let active_block_index = model.block_list().active_block_index();
let viewport = self.viewport_state(model.block_list(), input_mode, app);
viewport.is_block_in_view(active_block_index, BlockVisibilityMode::TopOfBlockVisible)
}
fn scroll_top_in_lines(
&self,
model: &TerminalModel,
input_mode: InputMode,
app: &AppContext,
) -> Lines {
let viewport = self.viewport_state(model.block_list(), input_mode, app);
viewport.scroll_top_in_lines()
}
fn is_vertically_scrollable(&self, app: &AppContext) -> bool {
let total_block_heights = self
.model
.lock()
.block_list()
.block_heights()
.summary()
.height;
let visible_rows = self.content_element_height_lines(app);
heights_approx_gt(total_block_heights, visible_rows)
}
}
fn read_from_clipboard(ctx: &mut ViewContext<TerminalView>) -> String {
TerminalView::read_from_clipboard(Some(ShellFamily::Posix), ctx)
}
#[test]
fn test_insert() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
let select_text = |view: &mut TerminalView, ctx: &mut ViewContext<TerminalView>| {
{
let mut model = view.model.lock();
model.start_command_execution();
let blocks = model.block_list_mut();
blocks.input('f');
blocks.linefeed();
blocks.preexec(PreexecValue::default());
blocks.on_finish_byte_processing(&ansi::ProcessorInput::new(&[]));
}
view.begin_block_text_selection(
BlockListPoint::new(1.0, 1),
Side::Right,
SelectionType::Semantic,
Vector2F::zero(),
ctx,
);
view.end_text_selection(ctx);
};
let assert_input_text_eq = |app: &mut App, expected_text: &str| {
terminal.read(app, |view, _ctx| {
view.input.read(app, |view, ctx| {
assert_eq!(view.buffer_text(ctx), String::from(expected_text));
});
});
};
let assert_selected_blocks_cardinality_eq =
|app: &mut App, expected_cardinality: BlockSelectionCardinality| {
terminal.read(app, |view, _ctx| {
assert_eq!(
view.selected_blocks.cardinality().as_keymap_context_value(),
expected_cardinality.as_keymap_context_value()
);
});
};
let assert_selected_text_eq = |app: &mut App, expected_text: Option<String>| {
terminal.update(app, |view, ctx| {
let semantic_selection = SemanticSelection::as_ref(ctx);
let model = view.model.lock();
let context_selected_text =
model.selection_to_string(semantic_selection, false, ctx);
assert_eq!(context_selected_text, expected_text);
});
};
// Shell Mode: Nothing selected
terminal.update(&mut app, |view, ctx| {
view.focus_terminal(ctx);
view.typed_characters_on_terminal("hello", ctx);
});
assert_input_text_eq(&mut app, "hello");
assert_selected_blocks_cardinality_eq(&mut app, BlockSelectionCardinality::None);
assert_selected_text_eq(&mut app, None);
// Shell Mode: Block selected
terminal.update(&mut app, |view, ctx| {
view.selected_blocks.reset_to_single(BlockIndex::zero());
view.focus_terminal(ctx);
view.typed_characters_on_terminal("_this", ctx);
});
assert_input_text_eq(&mut app, "hello_this");
assert_selected_blocks_cardinality_eq(&mut app, BlockSelectionCardinality::None);
assert_selected_text_eq(&mut app, None);
// Shell Mode: Text selected
terminal.update(&mut app, |view, ctx| {
select_text(view, ctx);
view.focus_terminal(ctx);
view.typed_characters_on_terminal("_is", ctx);
});
assert_input_text_eq(&mut app, "hello_this_is");
assert_selected_blocks_cardinality_eq(&mut app, BlockSelectionCardinality::None);
assert_selected_text_eq(&mut app, None);
// Activate Agent Mode, which should no longer allow text insertion to clear the selected block(s) or text
terminal.update(&mut app, |view, ctx| {
view.set_ai_input_mode_with_query(None, ctx);
});
// Agent Mode: Nothing selected
terminal.update(&mut app, |view, ctx| {
view.focus_terminal(ctx);
view.typed_characters_on_terminal("_your", ctx);
});
assert_input_text_eq(&mut app, "hello_this_is_your");
assert_selected_blocks_cardinality_eq(&mut app, BlockSelectionCardinality::None);
assert_selected_text_eq(&mut app, None);
// Agent Mode: Block selected
terminal.update(&mut app, |view, ctx| {
view.selected_blocks.reset_to_single(BlockIndex::zero());
view.focus_terminal(ctx);
view.typed_characters_on_terminal("_captain", ctx);
});
assert_input_text_eq(&mut app, "hello_this_is_your_captain");
assert_selected_blocks_cardinality_eq(&mut app, BlockSelectionCardinality::One);
assert_selected_text_eq(&mut app, None);
// Agent Mode: Text selected
terminal.update(&mut app, |view, ctx| {
select_text(view, ctx);
view.focus_terminal(ctx);
view.typed_characters_on_terminal("_speaking", ctx);
});
assert_input_text_eq(&mut app, "hello_this_is_your_captain_speaking");
assert_selected_blocks_cardinality_eq(&mut app, BlockSelectionCardinality::None);
assert_selected_text_eq(&mut app, Some("f".to_owned()));
})
}
const BODY_PREFIX: &str = "Latest output: ";
/// Regression test for CORE-1654. Tests the "Insert into Input" functionality from the context menu.
#[test]
fn test_insert_into_input() {
// Note that this is defined as a unit test rather than an integration test since it requires precise selections
// (where we don't want UI updates making the test brittle, due to hardcoded mouse positions).
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// TODO: Potentially explore if we can re-use helpers from `input_test.rs` (`select_first_command_line_of_block` and `insert_dummy_block`).
terminal.update(&mut app, |terminal_view, ctx| {
{
let mut terminal_model = terminal_view.model.lock();
let blocks = terminal_model.block_list_mut();
// Add two lines to the command grid and output grid in a new block.
let block_index = insert_block(blocks, "cmd_a\ncmd_b\n", "output_a\noutput_b\n");
let block = blocks.block_at(block_index).expect("block should exist");
// Selections are inclusive of endpoint, hence we need to identify the last column to select the first command.
let block_command_columns =
block.prompt_and_command_grid().grid_handler().columns();
let command_grid_offset = block.command_grid_offset();
// Create a selection that just spans the first line of the command grid in the block.
blocks.start_selection(
BlockListPoint::new(command_grid_offset, 0),
SelectionType::Simple,
Side::Left,
);
blocks.update_selection(
BlockListPoint::new(command_grid_offset, block_command_columns),
Side::Right,
);
let selection = blocks.selection();
assert!(selection.is_some());
}
terminal_view.context_menu_insert_selected_text(ctx);
});
// Confirm that the blocklist selection is cleared upon inserting into the input box.
terminal.read(&app, |terminal_view, _ctx| {
let terminal_model = terminal_view.model.lock();
let blocks = terminal_model.block_list();
let selection = blocks.selection();
assert!(
selection.is_none(),
"Expected no selections in the blocklist but got {selection:?}"
);
});
let input = terminal.read(&app, |terminal, _ctx| terminal.input().clone());
// Confirm that the input box has the correct text (the first line of the command grid was selected above).
input.read(&app, |input, ctx| {
assert_eq!(input.buffer_text(ctx), "cmd_a");
});
});
}
#[test]
fn test_copy_on_select() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Add some text and make sure we update the selection
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
model.start_command_execution();
let blocks = model.block_list_mut();
blocks.input('f');
blocks.input('o');
blocks.input('o');
blocks.linefeed();
blocks.preexec(PreexecValue::default());
blocks.on_finish_byte_processing(&ansi::ProcessorInput::new(&[]));
}
view.begin_block_text_selection(
BlockListPoint::new(1.0, 1),
Side::Right,
SelectionType::Semantic,
Vector2F::zero(),
ctx,
);
let selection_settings = SelectionSettings::as_ref(ctx);
assert!(selection_settings.copy_on_select_enabled());
assert_eq!("", &read_from_clipboard(ctx));
view.end_text_selection(ctx);
assert_eq!("foo", &read_from_clipboard(ctx));
});
})
}
#[test]
fn test_alt_screen_copy_on_select() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
// Enter alt screen and add text
let mut model = view.model.lock();
model.set_mode(ansi::Mode::SwapScreen {
save_cursor_and_clear_screen: true,
});
assert!(model.is_alt_screen_active());
model.alt_screen_mut().input('h');
}
// Ensure copy on select is enabled
let selection_settings = SelectionSettings::as_ref(ctx);
assert!(selection_settings.copy_on_select_enabled());
// Select input
view.begin_alt_selection(Point::new(0, 0), Side::Left, SelectionType::Simple, ctx);
assert_eq!("", &read_from_clipboard(ctx));
view.update_alt_selection(Point::new(0, 2), Side::Left, &Lines::zero(), ctx);
view.end_alt_selection(ctx);
// Ensure selection is copied
assert_eq!("h", &read_from_clipboard(ctx));
});
})
}
#[test]
fn test_alt_screen_select_with_sgr_mouse() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let (window_id, terminal) = add_window_with_id_and_terminal(&mut app, None);
let mut updated = HashSet::new();
updated.insert(app.root_view_id(window_id).unwrap());
let invalidation = WindowInvalidation {
updated,
..Default::default()
};
let presenter = Rc::new(RefCell::new(Presenter::new(window_id)));
let semantic_selection = SemanticSelection::mock(true, "");
let size_info = terminal.update(&mut app, |view, ctx| {
{
// Enter alt screen and enable SGR Mouse
let mut model = view.model.lock();
model.set_mode(ansi::Mode::SwapScreen {
save_cursor_and_clear_screen: true,
});
model.set_mode(ansi::Mode::SgrMouse);
assert!(model.is_alt_screen_active());
assert!(!should_intercept_mouse(&model, false, ctx));
assert!(should_intercept_mouse(&model, true, ctx));
// Write a bunch of characters into the alt screen.
// ABCDEFG
// HIJKLMN
// OPQRSTU
// VWXYZ[\
// ]^_`abc
// defghij
// klmnopq
// rstuvwx
// yz{|}~
// € ‚ƒ„…†
// ‡ˆ‰Š‹Œ
let mut ascii: u8 = 65;
for _ in 0..view.size_info.rows {
for _ in 0..view.size_info.columns {
model.alt_screen_mut().input(ascii as char);
ascii += 1;
}
}
*view.size_info
}
});
// We need to manually trigger re-renders to ensure the AltScreenElement is recreated, e.g.
// so its `is_terminal_selecting` property will be up-to-date.
macro_rules! rerender {
($app:ident, $presenter:expr, $invalidation:expr, $size_info:expr) => {
app.update(enclose!((presenter, invalidation) move |ctx| {
presenter
.borrow_mut()
.invalidate(invalidation, ctx);
presenter.borrow_mut().build_scene(
vec2f(size_info.pane_width_px, size_info.pane_height_px),
1.,
None,
ctx,
);
}));
}
}
// The start and end positions corresponds to 'J'
// and 'a' in the grid, respectively.
//
// We adjust the vertical coordinates to account for padding
// in the alt-screen.
let start_position = vec2f(
2. * size_info.cell_width_px.as_f32(),
2. * size_info.cell_height_px.as_f32() - 1.,
);
let end_position = vec2f(
5. * size_info.cell_width_px.as_f32(),
5. * size_info.cell_height_px.as_f32() - 1.,
);
// Simulate a mouse drag from the "J" to the "a" cell.
rerender!(app, presenter, invalidation, size_info);
app.update(enclose!((presenter) move |ctx| {
ctx.simulate_window_event(
galaxyui::Event::LeftMouseDown {
position: start_position,
modifiers: Default::default(),
click_count: 1,
is_first_mouse: false,
},
window_id,
presenter.clone(),
);
}));
rerender!(app, presenter, invalidation, size_info);
app.update(enclose!((presenter) move |ctx| {
ctx.simulate_window_event(
galaxyui::Event::LeftMouseDragged {
position: end_position,
modifiers: Default::default(),
},
window_id,
presenter.clone(),
);
}));
rerender!(app, presenter, invalidation, size_info);
app.update(enclose!((presenter) move |ctx| {
ctx.simulate_window_event(
galaxyui::Event::LeftMouseUp {
position: end_position,
modifiers: Default::default(),
},
window_id,
presenter.clone(),
);
}));
// No selection should've occurred as we aren't intercepting mouse events.
terminal.read(&app, |view, ctx| {
let selected_text =
view.model
.lock()
.selection_to_string(&semantic_selection, false, ctx);
assert_eq!(selected_text, None);
});
// This time, hold Shift key for all mouse events.
rerender!(app, presenter, invalidation, size_info);
app.update(enclose!((presenter) move |ctx| {
ctx.simulate_window_event(
galaxyui::Event::LeftMouseDown {
position: start_position,
modifiers: ModifiersState {
shift: true,
..Default::default()
},
click_count: 1,
is_first_mouse: false,
},
window_id,
presenter.clone(),
);
}));
rerender!(app, presenter, invalidation, size_info);
app.update(enclose!((presenter) move |ctx| {
ctx.simulate_window_event(
galaxyui::Event::LeftMouseDragged {
position: end_position,
modifiers: ModifiersState {
shift: true,
..Default::default()
},
},
window_id,
presenter.clone(),
);
}));
rerender!(app, presenter, invalidation, size_info);
app.update(enclose!((presenter) move |ctx| {
ctx.simulate_window_event(
galaxyui::Event::LeftMouseUp {
position: end_position,
modifiers: ModifiersState {
shift: true,
..Default::default()
},
},
window_id,
presenter.clone(),
);
}));
// This time we expect a selection since the Shift key had been held for this mouse drag.
terminal.read(&app, |view, ctx| {
let selected_text =
view.model
.lock()
.selection_to_string(&semantic_selection, false, ctx);
assert_eq!(selected_text.as_ref().unwrap(), "JKLMNOPQRSTUVWXYZ[\\]^_`a");
});
})
}
// Regression test for WAR-3433 on find bar selection crash.
#[test]
fn test_find_bar_select() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Add some text and make sure we update the selection
terminal.update(&mut app, |view, ctx| {
// Mock a block with content 'foo g'.
{
let mut model = view.model.lock();
model.start_command_execution();
let blocks = model.block_list_mut();
blocks.input('f');
blocks.input('o');
blocks.input('o');
blocks.input(' ');
blocks.input('g');
blocks.linefeed();
blocks.preexec(PreexecValue::default());
blocks.on_finish_byte_processing(&ansi::ProcessorInput::new(&[]));
}
// Select 'foo'.
view.begin_block_text_selection(
BlockListPoint::new(1.0, 1),
Side::Right,
SelectionType::Semantic,
Vector2F::zero(),
ctx,
);
let selection_settings = SelectionSettings::as_ref(ctx);
assert!(selection_settings.copy_on_select_enabled());
assert_eq!("", &read_from_clipboard(ctx));
view.end_text_selection(ctx);
assert_eq!("foo", &read_from_clipboard(ctx));
// Show find bar. The find bar should have selected text 'foo' in its editor.
view.show_find_bar(ctx);
view.find_bar.read(ctx, |find, ctx| {
find.editor().read(ctx, |editor, ctx| {
assert_eq!("foo".to_string(), editor.selected_text(ctx));
})
});
// Now select 'foo g'.
view.begin_block_text_selection(
BlockListPoint::new(1.0, 1),
Side::Right,
SelectionType::Lines,
Vector2F::zero(),
ctx,
);
let selection_settings = SelectionSettings::as_ref(ctx);
assert!(selection_settings.copy_on_select_enabled());
assert_eq!("foo", &read_from_clipboard(ctx));
view.end_text_selection(ctx);
assert_eq!("foo g", &read_from_clipboard(ctx));
// Show find bar. The find bar should have selected text 'foo g' in its editor.
view.show_find_bar(ctx);
view.find_bar.read(ctx, |find, ctx| {
find.editor().read(ctx, |editor, ctx| {
assert_eq!("foo g".to_string(), editor.selected_text(ctx));
})
});
});
})
}
#[test]
fn test_viewport_iter_most_recent_at_bottom() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let mut model = view.model.lock();
model.simulate_block("ls", "foo");
model.simulate_block("echo multiline", "bar\nhey");
let viewport = view.viewport_state(model.block_list(), InputMode::PinnedToBottom, ctx);
let mut iter = viewport.iter();
let first_block = iter.next().expect("item 1");
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(1)),
first_block.block_index
);
assert_eq!(
std::convert::Into::<TotalIndex>::into(1),
first_block.entry_index
);
assert!(first_block.block_height_item.height().into_lines() > Lines::zero());
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(1)),
viewport.topmost_visible_block()
);
let second_block = iter.next().expect("item 2");
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(2)),
second_block.block_index
);
assert_eq!(
std::convert::Into::<TotalIndex>::into(2),
second_block.entry_index
);
assert!(
second_block.block_height_item.height() > first_block.block_height_item.height()
);
assert!(viewport.is_block_in_view(
std::convert::Into::<BlockIndex>::into(2),
BlockVisibilityMode::TopOfBlockVisible
));
let third_block = iter.next().expect("item 3");
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(3)),
third_block.block_index
);
assert_eq!(
std::convert::Into::<TotalIndex>::into(3),
third_block.entry_index
);
assert_eq!(0., third_block.block_height_item.height().as_f64());
});
})
}
#[test]
fn test_viewport_iter_most_recent_at_top() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx: &mut ViewContext<'_, TerminalView>| {
let mut model = view.model.lock();
model.simulate_block("ls", "foo");
model.simulate_block("echo multiline", "bar\nhey");
let viewport = view.viewport_state(model.block_list(), InputMode::PinnedToTop, ctx);
let mut iter = viewport.iter();
let echo_block = iter.next().expect("item 2");
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(2)),
echo_block.block_index
);
assert_eq!(
std::convert::Into::<TotalIndex>::into(2),
echo_block.entry_index
);
assert!(echo_block.block_height_item.height().into_lines() > Lines::zero());
assert_eq!(Pixels::zero(), viewport.offset_to_top_of_first_block(ctx));
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(2)),
viewport.topmost_visible_block()
);
assert!(viewport.is_block_in_view(
std::convert::Into::<BlockIndex>::into(2),
BlockVisibilityMode::TopOfBlockVisible
));
let ls_block = iter.next().expect("item 1");
assert_eq!(
Some(std::convert::Into::<BlockIndex>::into(1)),
ls_block.block_index
);
assert_eq!(
std::convert::Into::<TotalIndex>::into(1),
ls_block.entry_index
);
assert!(
echo_block.block_height_item.height().as_f64()
> ls_block.block_height_item.height().as_f64()
);
});
})
}
#[test]
fn test_viewport_most_recent_at_top() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let mut model = view.model.lock();
model.simulate_block("ls", "foo");
model.simulate_block("echo multiline", "bar\nhey");
let viewport = view.viewport_state(model.block_list(), InputMode::PinnedToTop, ctx);
// Most recent block should be visible.
let topmost_visible_block = viewport.topmost_visible_block().unwrap();
assert!(viewport.is_block_in_view(
topmost_visible_block,
BlockVisibilityMode::TopOfBlockVisible
));
assert_eq!(Pixels::zero(), viewport.offset_to_top_of_first_block(ctx));
assert_eq!(0., viewport.scroll_top_in_lines().as_f64());
assert!(matches!(
viewport.next_scroll_position(
ScrollPositionUpdate::AfterScrollEvent {
scroll_delta: 1.0.into_lines()
},
ctx
),
ScrollPosition::FixedAtPosition { .. }
));
assert_eq!(
Lines::zero(),
viewport.top_of_block_in_lines(topmost_visible_block)
);
assert!(matches!(
viewport.scroll_position_at_bottom_of_block(topmost_visible_block),
ScrollPosition::FollowsBottomOfMostRecentBlock
));
let block_list_point = viewport
.screen_coord_to_blocklist_point(
vec2f(0., 0.),
SnackbarPoint {
coord: vec2f(0., 0.),
translation_mode: SnackbarTranslationMode::WithinSnackbar,
},
ClampingMode::ClampToGrid,
)
.unwrap();
assert_eq!(
Some(2.into()),
viewport.block_index_from_point(block_list_point)
);
});
})
}
#[test]
fn test_scroll_fixed_to_bottom() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.read(&app, |view, _| {
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
});
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
// Put in enough blocks so that the view should be scrollable
for _ in 0..100 {
model.simulate_block("ls", "foo");
}
}
assert!(view.is_vertically_scrollable(ctx));
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
view.scroll(1.0.into_lines(), ctx);
let expected_scroll_top = {
let model = view.model.lock();
model.block_list().block_heights().summary().height
- view.content_element_height_lines(ctx)
- 1.0.into_lines()
};
assert_eq!(
view.scroll_position(),
ScrollPosition::FixedAtPosition {
scroll_lines: ScrollLines::ScrollTop(expected_scroll_top)
},
);
// Now add to the active block and make sure we don't scroll
{
let mut model = view.model.lock();
model.simulate_cmd("test");
}
{
let mut model = view.model.lock();
for _ in 0..100 {
model.linefeed();
}
}
assert_eq!(
view.scroll_position(),
ScrollPosition::FixedAtPosition {
scroll_lines: ScrollLines::ScrollTop(expected_scroll_top)
},
);
});
})
}
#[test]
fn test_scroll_to_row() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
// Put in enough blocks so that the view should be scrollable
for _ in 0..50 {
model.simulate_block("ls", "foo\nfie\nfay\nfoe\nfum");
}
}
assert!(view.is_vertically_scrollable(ctx));
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
// Scroll upwards (no snackbar)
let a = BlockListPoint::new(30.0, 0);
view.scroll_to_row_if_not_visible(a.row.into_lines(), ctx);
assert_eq!(
view.scroll_position(),
ScrollPosition::FixedAtPosition {
scroll_lines: ScrollLines::ScrollTop(30.0.into_lines())
}
);
// Don't scroll at all
let b = BlockListPoint::new(38.0, 0);
view.scroll_to_row_if_not_visible(b.row.into_lines(), ctx);
assert_eq!(
view.scroll_position(),
ScrollPosition::FixedAtPosition {
scroll_lines: ScrollLines::ScrollTop(30.0.into_lines())
}
);
// Scroll downwards
let c = BlockListPoint::new(100.0, 0);
view.scroll_to_row_if_not_visible(c.row.into_lines(), ctx);
assert_eq!(
view.scroll_position(),
ScrollPosition::FixedAtPosition {
scroll_lines: ScrollLines::ScrollTop(90.5.into_lines())
}
);
});
})
}
#[test]
fn test_stable_scrolling_during_grid_truncation() {
App::test((), |mut app| async move {
const MAX_GRID_SIZE: usize = 50;
const INPUT_MODE: InputMode = InputMode::PinnedToBottom;
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Note: this test is done in a single `update` to prevent
// any changes in the presenter's position cache throughout.
terminal.update(&mut app, |view, ctx| {
// Set up the block list by creating a long-running
// block that spans the entire viewport.
{
let mut model = view.model.lock();
model.update_max_grid_size(MAX_GRID_SIZE);
// Create a dummy, finished block and a long-running block.
model.simulate_block("ls", "foo");
model.simulate_long_running_block("cat", "");
assert!(model
.block_list()
.active_block()
.is_active_and_long_running());
// Add enough newlines so that the long-running block spans at
// least the viewport and surely exceeds the grid size.
let mut i = 0;
while view.is_top_of_active_block_in_viewport(&model, INPUT_MODE, ctx)
|| i < MAX_GRID_SIZE * 2
{
model.process_bytes("\n");
i += 1;
}
}
// Scroll up one line.
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
view.scroll(1.into_lines(), ctx);
assert!(matches!(
view.scroll_position(),
ScrollPosition::FixedWithinLongRunningBlock { .. }
));
// Introduce new lines and make sure the scroll-top is adjusted as expected.
{
let mut model = view.model.lock();
let active_block_index = model.block_list().active_block_index();
let scroll_top_before_scrolling = view.scroll_top_in_lines(&model, INPUT_MODE, ctx);
// To get to the top of the block, we need 50 lines for output grid and
// then one line for command grid.
for i in 1..=(MAX_GRID_SIZE + 1) {
model.process_bytes("\n");
let actual_scroll_top = view.scroll_top_in_lines(&model, INPUT_MODE, ctx);
let expected_scroll_top = scroll_top_before_scrolling - i.into_lines();
assert_eq!(actual_scroll_top, expected_scroll_top);
}
// Flush one full line in case the top of the block doesn't perfectly
// line up with full lines (e.g. due to padding).
model.process_bytes("\n");
// Any remaining newlines should not move the scroll-top;
// it should be "locked" at the top of the block.
for _ in 0..MAX_GRID_SIZE {
model.process_bytes("\n");
let viewport = view.viewport_state(model.block_list(), INPUT_MODE, ctx);
let actual_scroll_top = viewport.scroll_top_in_lines();
let expected_scroll_top = viewport.top_of_block_in_lines(active_block_index);
assert_eq!(actual_scroll_top, expected_scroll_top);
}
}
// Scroll up one line, bringing the previous block into the viewport.
view.scroll(1.into_lines(), ctx);
assert!(matches!(
view.scroll_position(),
ScrollPosition::FixedAtPosition { .. }
));
// Introduce newlines and make sure the scroll-top does _not_ change anymore.
{
let mut model = view.model.lock();
let scroll_top_before_newlines = view.scroll_top_in_lines(&model, INPUT_MODE, ctx);
for _ in 0..MAX_GRID_SIZE {
model.process_bytes("\n");
let new_scroll_top = view.scroll_top_in_lines(&model, INPUT_MODE, ctx);
assert_eq!(scroll_top_before_newlines, new_scroll_top);
}
}
});
})
}
#[test]
fn test_clear_buffer() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
for _ in 0..10 {
model.simulate_block("ls", "foo");
}
assert!(!model.block_list().blocks().is_empty());
}
view.bookmark_block(&BlockIndex::zero(), ctx);
view.clear_buffer(ctx);
{
let model = view.model.lock();
// There should be only one precmd block.
assert_eq!(model.block_list().blocks().len(), 1);
assert_eq!(view.bookmarked_blocks.len(), 0);
}
});
})
}
#[test]
fn test_clear_buffer_clears_autosuggestion() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
// Set a next command suggestion (empty input)
view.input.update(ctx, |input, ctx| {
input.editor().update(ctx, |editor, ctx| {
editor.set_autosuggestion(
"git status",
AutosuggestionLocation::EndOfBuffer,
AutosuggestionType::Command {
was_intelligent_autosuggestion: true,
},
ctx,
);
});
});
// Verify autosuggestion is present
view.input.read(ctx, |input, ctx| {
input.editor().read(ctx, |editor, _ctx| {
assert!(
editor.active_autosuggestion(),
"Autosuggestion should be active before clear_buffer"
);
});
});
// Clear the buffer
view.clear_buffer(ctx);
// Verify autosuggestion is cleared
view.input.read(ctx, |input, ctx| {
input.editor().read(ctx, |editor, _ctx| {
assert!(
!editor.active_autosuggestion(),
"Autosuggestion should be cleared after clear_buffer"
);
});
});
});
})
}
#[test]
fn test_bookmark_blocks_navigation() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
for _ in 0..10 {
model.simulate_block("ls", "foo");
}
assert!(!model.block_list().blocks().is_empty());
}
view.bookmark_block(&BlockIndex::zero(), ctx);
view.bookmark_block(&BlockIndex::from(1), ctx);
view.bookmark_block(&BlockIndex::from(4), ctx);
view.bookmark_up(ctx);
assert_eq!(view.selected_blocks.tail(), Some(4.into()));
view.bookmark_down(ctx);
assert_eq!(view.selected_blocks.tail(), Some(0.into()));
view.bookmark_up(ctx);
assert_eq!(view.selected_blocks.tail(), Some(4.into()));
view.bookmark_up(ctx);
assert_eq!(view.selected_blocks.tail(), Some(1.into()));
view.bookmark_up(ctx);
assert_eq!(view.selected_blocks.tail(), Some(0.into()));
view.bookmark_down(ctx);
assert_eq!(view.selected_blocks.tail(), Some(1.into()));
view.bookmark_down(ctx);
assert_eq!(view.selected_blocks.tail(), Some(4.into()));
});
})
}
fn run_navigation_test(input_mode: InputMode) {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.read(&app, |view, _ctx| {
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
});
terminal.update(&mut app, |view, ctx| {
InputModeSettings::handle(ctx).update(ctx, |input_mode_settings, ctx| {
let _ = input_mode_settings.input_mode.set_value(input_mode, ctx);
});
{
let mut model = view.model.lock();
// Put in enough blocks so that the view should be scrollable
for _ in 0..100 {
model.simulate_block("ls", "foo");
}
// Put in one block that is larger than the viewport height.
model.simulate_block("ls", "foo\n".repeat(100).as_str())
}
assert!(view.is_vertically_scrollable(ctx));
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
view.select_most_recent_blocks(1, ctx);
assert_eq!(view.selected_blocks.tail(), Some(101.into()));
view.select_less_recent_block(false /* is_shift_down */, ctx);
assert_eq!(view.selected_blocks.tail(), Some(100.into()));
view.select_more_recent_block(
true, /* is_cmd_down */
false, /* is_shift_down */
ctx,
);
assert_ne!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
assert_eq!(view.selected_blocks.tail(), Some(101.into()));
view.select_more_recent_block(
true, /* is_cmd_down */
false, /* is_shift_down */
ctx,
);
if input_mode.is_inverted_blocklist() {
// In the inverted case, we intentionally align to the
// top of the most recent block here, not to its bottom
assert!(matches!(
view.scroll_position(),
ScrollPosition::FixedAtPosition { .. }
));
} else {
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
}
assert_eq!(view.selected_blocks.tail(), Some(101.into()));
view.select_more_recent_block(
true, /* is_cmd_down */
false, /* is_shift_down */
ctx,
);
assert_eq!(view.selected_blocks.tail(), None);
});
});
}
#[test]
fn test_navigate_blocks() {
run_navigation_test(InputMode::PinnedToBottom);
}
// #[test]
// fn test_navigate_blocks_inverted_blocklist() {
// run_navigation_test(InputMode::PinnedToTop);
// }
#[test]
fn test_alt_scroll_sequences() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Test scrolling a distance of zero lines.
terminal.update(&mut app, |view, _| {
let content = view.alt_scroll_sequences(0);
assert!(content.is_empty());
});
// Scroll down 3 lines
terminal.update(&mut app, |view, _| {
let content = view.alt_scroll_sequences(-3);
assert_eq!(content.len(), 3 * 3);
assert_eq!(
content
.into_iter()
.filter(|b| *b == escape_sequences::EscCodes::ARROW_DOWN)
.count(),
3
);
});
// Scroll up 5 lines
terminal.update(&mut app, |view, _| {
let content = view.alt_scroll_sequences(5);
assert_eq!(content.len(), 5 * 3);
assert_eq!(
content
.into_iter()
.filter(|b| *b == escape_sequences::EscCodes::ARROW_UP)
.count(),
5
);
});
})
}
#[test]
fn test_not_bootstrapped() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let model = view.model.lock();
assert!(view.is_input_box_visible(&model, ctx));
drop(model);
assert_eq!(view.active_session_path_if_local(ctx), None);
});
})
}
#[test]
fn test_block_select() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.selected_blocks
.toggle(10.into(), Some(11.into()), Some(9.into()));
let single_mouse_down = BlockSelectAction::MouseDown(Some(1.into()));
// On Mac, we use cmd-click to toggle block selections, but
// we use ctrl-click on non-Mac platforms.
let single_mouse_up = if cfg!(target_os = "macos") {
BlockSelectAction::MouseUp {
block_index: 1.into(),
is_ctrl_down: false,
is_cmd_down: true,
is_shift_down: false,
}
} else {
BlockSelectAction::MouseUp {
block_index: 1.into(),
is_ctrl_down: true,
is_cmd_down: false,
is_shift_down: false,
}
};
view.block_select(&single_mouse_down, true, ctx);
view.block_select(&single_mouse_up, true, ctx);
assert!(view.selected_blocks.is_selected(1.into()));
assert!(view.selected_blocks.is_selected(10.into()));
let range_mouse_down = BlockSelectAction::MouseDown(Some(5.into()));
let range_mouse_up = BlockSelectAction::MouseUp {
block_index: 5.into(),
is_ctrl_down: false,
is_cmd_down: false,
is_shift_down: true,
};
view.block_select(&range_mouse_down, true, ctx);
view.block_select(&range_mouse_up, true, ctx);
assert!(!view.selected_blocks.is_selected(10.into()));
assert_eq!(view.selected_blocks_pivot_index(), Some(1.into()));
assert_eq!(view.selected_blocks_tail_index(), Some(5.into()));
});
})
}
#[test]
fn test_select_all_blocks() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
// Put in enough blocks so that the view should be scrollable
for _ in 0..100 {
model.simulate_block("ls", "foo");
}
}
assert!(view.is_vertically_scrollable(ctx));
view.select_all_blocks(ctx);
assert_eq!(view.selected_blocks_pivot_index().unwrap(), 1.into());
assert_eq!(view.selected_blocks_tail_index().unwrap(), 100.into());
for i in 1..100 {
assert!(view.selected_blocks.is_selected(i.into()));
}
});
})
}
#[test]
fn test_expand_selection_above_and_below() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
// Put in enough blocks so that the view should be scrollable
for _ in 0..100 {
model.simulate_block("ls", "foo");
}
}
assert!(view.is_vertically_scrollable(ctx));
// helper to ensure indices are all selected
fn assert_all_selected(selected_blocks: &SelectedBlocks, indices: Vec<BlockIndex>) {
for &idx in indices.iter() {
assert!(selected_blocks.is_selected(idx));
}
}
view.selected_blocks
.toggle(5.into(), Some(6.into()), Some(4.into()));
assert_all_selected(&view.selected_blocks, vec![5.into()]);
view.select_more_recent_block(
false, /* is_cmd_down */
true, /* is_shift_down */
ctx,
);
assert_all_selected(&view.selected_blocks, vec![5.into(), 6.into()]);
view.select_more_recent_block(
false, /* is_cmd_down */
true, /* is_shift_down */
ctx,
);
assert_all_selected(&view.selected_blocks, vec![5.into(), 6.into(), 7.into()]);
view.select_less_recent_block(true /* is_shift_down */, ctx);
assert_all_selected(&view.selected_blocks, vec![5.into(), 6.into()]);
view.select_less_recent_block(true /* is_shift_down */, ctx);
assert_all_selected(&view.selected_blocks, vec![5.into()]);
view.select_less_recent_block(true /* is_shift_down */, ctx);
assert_all_selected(&view.selected_blocks, vec![5.into(), 4.into()]);
view.select_more_recent_block(
false, /* is_cmd_down */
true, /* is_shift_down */
ctx,
);
assert_all_selected(&view.selected_blocks, vec![5.into()]);
});
})
}
#[test]
fn test_copy_blocks() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let (first_command, first_output) = ("ls", "foo");
let (second_command, second_output) = ("pwd", "bar");
{
let mut model = view.model.lock();
model.simulate_block(first_command, first_output);
model.simulate_block(second_command, second_output);
}
// select a single block
view.selected_blocks.toggle(2.into(), None, Some(1.into()));
// test copy for a single block
view.copy_blocks(BlockEntity::Command, ctx);
assert_eq!(read_from_clipboard(ctx), second_command.to_string());
view.copy_blocks(BlockEntity::Output, ctx);
assert_eq!(read_from_clipboard(ctx), second_output.to_string());
view.copy_blocks(BlockEntity::CommandAndOutput, ctx);
assert_eq!(
read_from_clipboard(ctx),
format!("{second_command}\n{second_output}")
);
// select another block (in reverse)
view.selected_blocks.toggle(1.into(), Some(2.into()), None);
// test copy semantics for multiple blocks
view.copy_blocks(BlockEntity::Command, ctx);
let expected_commands_str = format!("{first_command}\n{second_command}");
assert_eq!(read_from_clipboard(ctx), expected_commands_str);
view.copy_blocks(BlockEntity::Output, ctx);
let expected_outputs_str = format!("{first_output}\n{second_output}");
assert_eq!(read_from_clipboard(ctx), expected_outputs_str);
view.copy_blocks(BlockEntity::CommandAndOutput, ctx);
let expected_both_str =
format!("{first_command}\n{first_output}\n{second_command}\n{second_output}");
assert_eq!(read_from_clipboard(ctx), expected_both_str);
});
})
}
#[test]
fn test_reinput_blocks() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let (first_command, first_output) = ("ls", "foo");
let (second_command, second_output) = ("pwd", "bar");
{
let mut model = view.model.lock();
model.simulate_block(first_command, first_output);
model.simulate_block(second_command, second_output);
}
// test reinput command for single block
view.selected_blocks.toggle(2.into(), None, Some(1.into()));
view.reinput_commands(false /* as_root */, ctx);
assert_eq!(view.input().as_ref(ctx).buffer_text(ctx), second_command);
view.selected_blocks.toggle(2.into(), None, Some(1.into()));
view.reinput_commands(true /* as_root */, ctx);
assert_eq!(
view.input().as_ref(ctx).buffer_text(ctx),
format!("sudo {second_command}")
);
// test reinput commands for multiple blocks (selected in reverse)
view.selected_blocks.toggle(2.into(), None, Some(1.into()));
view.selected_blocks.toggle(1.into(), Some(2.into()), None);
view.reinput_commands(false /* as_root */, ctx);
assert_eq!(
view.input().as_ref(ctx).buffer_text(ctx),
format!("{first_command}\n{second_command}")
);
view.selected_blocks.toggle(2.into(), None, Some(1.into()));
view.selected_blocks.toggle(1.into(), Some(2.into()), None);
view.reinput_commands(true /* as_root */, ctx);
assert_eq!(
view.input().as_ref(ctx).buffer_text(ctx),
format!("sudo {first_command}\nsudo {second_command}")
);
});
})
}
fn run_find_test(input_mode: InputMode) {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
InputModeSettings::handle(ctx).update(ctx, |input_mode_settings, ctx| {
let _ = input_mode_settings.input_mode.set_value(input_mode, ctx);
});
let (first_command, first_output) = ("ls", "foo");
let (second_command, second_output) = ("pwd", "foobar foo beans");
let (third_command, third_output) = ("fools", "baz");
{
let mut model = view.model.lock();
model.simulate_block(first_command, first_output);
model.simulate_block(second_command, second_output);
model.simulate_block(third_command, third_output);
}
view.show_find_bar(ctx);
// Test without find_in_block enabled (results should be selection-agnostic)
view.find_bar.update(ctx, |view, _ctx| {
view.display_find_within_block = FindWithinBlockState::Disabled;
});
// find when no block is selected
view.handle_find_event(
&FindEvent::Update {
query: Some("foo".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
4
);
assert_eq!(
view.find_model
.as_ref(ctx)
.block_list_find_run()
.expect("BlockListFindRun exists.")
.focused_match_block_index()
.expect("Focused match exists."),
3.into()
);
view.handle_find_event(
&FindEvent::NextMatch {
direction: FindDirection::Down,
},
ctx,
);
if input_mode.is_inverted_blocklist() {
// should go "down" to middle block
assert_eq!(
view.find_model
.as_ref(ctx)
.block_list_find_run()
.expect("BlockListFindRun exists.")
.focused_match_block_index()
.expect("Focused match exists."),
2.into()
);
} else {
// should loop to earliest block
assert_eq!(
view.find_model
.as_ref(ctx)
.block_list_find_run()
.expect("BlockListFindRun exists.")
.focused_match_block_index()
.expect("Focused match exists."),
1.into()
);
}
// find when a single block is selected
view.selected_blocks.reset_to_single(2.into());
view.handle_find_event(
&FindEvent::Update {
query: Some("ls".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
2
);
assert_block_has_find_match(view.find_model.as_ref(ctx), 1.into());
assert_block_has_find_match(view.find_model.as_ref(ctx), 3.into());
// Test with find_in_block enabled
view.find_bar.update(ctx, |view, _ctx| {
view.display_find_within_block = FindWithinBlockState::Enabled;
});
// find when no block is selected
view.selected_blocks.reset();
view.handle_find_event(
&FindEvent::Update {
query: Some("foo".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
0
);
// find when a single block is selected
view.selected_blocks.reset_to_single(2.into());
view.handle_find_event(
&FindEvent::Update {
query: Some("pwd".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
1
);
assert_block_has_find_match(view.find_model.as_ref(ctx), 2.into());
// find when multiple blocks are selected, and find in block is enabled
view.selected_blocks.toggle(3.into(), Some(2.into()), None);
view.handle_find_event(
&FindEvent::Update {
query: Some("foo".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
3
);
assert_block_has_find_match(view.find_model.as_ref(ctx), 2.into());
assert_block_has_find_match(view.find_model.as_ref(ctx), 3.into());
});
})
}
#[test]
fn test_find_in_blocks() {
run_find_test(InputMode::PinnedToBottom);
}
#[test]
fn test_find_in_blocks_inverted_blocklist() {
run_find_test(InputMode::PinnedToTop);
}
#[test]
fn test_case_sensitive_find() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let (first_command, first_output) = ("ls", "foo");
let (second_command, second_output) = ("pwd", "fOObar");
let (third_command, third_output) = ("FoOls", "baz");
{
let mut model = view.model.lock();
model.simulate_block(first_command, first_output);
model.simulate_block(second_command, second_output);
model.simulate_block(third_command, third_output);
}
view.show_find_bar(ctx);
// Test without case sensitivity enabled (no blocks enabled)
view.handle_find_event(
&FindEvent::Update {
query: Some("fOO".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
3
);
// Test without case sensitivity enabled, but with find in block
view.find_bar.update(ctx, |view, _ctx| {
view.display_find_within_block = FindWithinBlockState::Enabled;
});
view.selected_blocks.reset_to_single(1.into());
view.update_find_selection(ctx);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
1
);
assert_block_has_find_match(view.find_model.as_ref(ctx), 1.into());
// Test with case sensitivity enabled (one block enabled)
view.handle_find_event(
&FindEvent::ToggleCaseSensitivity {
is_case_sensitive: true,
},
ctx,
);
view.selected_blocks.reset_to_single(1.into());
view.update_find_selection(ctx);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
0
);
view.selected_blocks.reset_to_single(2.into());
view.update_find_selection(ctx);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
1
);
assert_block_has_find_match(view.find_model.as_ref(ctx), 2.into());
// Test with case sensitivity enabled (no blocks enabled)
view.selected_blocks.reset();
view.find_bar.update(ctx, |view, _ctx| {
view.display_find_within_block = FindWithinBlockState::Disabled;
});
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
1
);
assert_block_has_find_match(view.find_model.as_ref(ctx), 2.into());
// Change regex to mismatch case sensitivity across all blocks
view.handle_find_event(
&FindEvent::Update {
query: Some("FOO".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
0
);
});
})
}
#[test]
fn test_find_bar_prefix_search() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let (command_1, output_1) = ("echo foo", "foo");
let (command_2, output_2) = ("echo bar foo", "bar foo");
{
let mut model = view.model.lock();
model.simulate_block(command_1, output_1);
model.simulate_block(command_2, output_2);
}
view.show_find_bar(ctx);
// Test without regex enabled
view.handle_find_event(
&FindEvent::Update {
query: Some("^foo".to_string()),
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
0
);
view.handle_find_event(
&FindEvent::ToggleRegexSearch {
is_regex_enabled: true,
},
ctx,
);
assert_eq!(
view.find_model.as_ref(ctx).visible_block_list_match_count(),
1
);
});
});
}
#[test]
fn test_create_notification_shorter_than_max() {
let command = "cargo run";
let output = "error: failed to find directory";
let command_succeeded = false;
let block_duration = Duration::new(4, 2);
let trigger = NotificationsTrigger::LongRunningCommand(command_succeeded, block_duration);
let actual_content =
trigger.create_notification_content(command.to_string(), output.to_string());
let expected_title = format!("'{command}' failed after 4s");
let expected_body = format!("{BODY_PREFIX}{output}");
assert_eq!(actual_content.title, expected_title);
assert_eq!(actual_content.body, expected_body);
}
#[test]
fn test_create_notification_as_long_as_max() {
let expected_title_suffix = " finished after 4s";
let max_command_len = UserNotification::MAX_TITLE_LENGTH - expected_title_suffix.len() - 2;
let command = "a".repeat(max_command_len);
let max_output_len = UserNotification::MAX_BODY_LENGTH - BODY_PREFIX.len();
let output = "a".repeat(max_output_len);
let command_succeeded = true;
let block_duration = Duration::new(4, 2);
let trigger = NotificationsTrigger::LongRunningCommand(command_succeeded, block_duration);
let actual_content =
trigger.create_notification_content(command.to_string(), output.to_string());
let expected_title = format!("'{command}'{expected_title_suffix}");
let expected_body = format!("{BODY_PREFIX}{output}");
assert_eq!(actual_content.title, expected_title);
assert_eq!(actual_content.body, expected_body);
}
#[test]
fn test_create_notification_longer_than_max() {
let expected_title_suffix = " finished after 4s";
let max_command_len = UserNotification::MAX_TITLE_LENGTH - expected_title_suffix.len() - 2;
let command = "a".repeat(max_command_len + 1);
let max_output_len = UserNotification::MAX_BODY_LENGTH - BODY_PREFIX.len();
let output = "a".repeat(max_output_len + 1);
let command_succeeded = true;
let block_duration = Duration::new(4, 2);
let trigger = NotificationsTrigger::LongRunningCommand(command_succeeded, block_duration);
let actual_content =
trigger.create_notification_content(command.to_string(), output.to_string());
let expected_title = format!(
"'{}...'{expected_title_suffix}",
&command[..max_command_len - 3]
);
let expected_body = format!("{BODY_PREFIX}...{}", &output[..max_output_len - 3]);
assert_eq!(actual_content.title, expected_title);
assert_eq!(actual_content.body, expected_body);
}
#[test]
fn test_create_notification_char_boundaries_respected() {
let expected_title_suffix = " finished after 4s";
let max_command_len = UserNotification::MAX_TITLE_LENGTH - expected_title_suffix.len() - 2;
let command = "😊".repeat(max_command_len + 1);
let output = "error: failed to find directory";
let command_succeeded = true;
let block_duration = Duration::new(4, 2);
let trigger = NotificationsTrigger::LongRunningCommand(command_succeeded, block_duration);
let actual_content = trigger.create_notification_content(command, output.to_string());
let expected_command_prefix = "😊".repeat(max_command_len - 3);
let expected_title = format!("'{expected_command_prefix}...'{expected_title_suffix}",);
assert_eq!(actual_content.title, expected_title);
}
#[test]
fn test_banner_for_incompatible_plugins() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
SessionSettings::handle(&app).update(&mut app, |session_settings, ctx| {
let _ = session_settings.honor_ps1.set_value(true, ctx);
});
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "zsh".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "zsh".to_owned(),
shell_plugins: Some(HashSet::from(["p10k_unsupported".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
200 => terminal.read(&app, |view, _ctx| view
.is_incompatible_configuration_banner_open),
"Banner did not open in time"
);
})
}
#[test]
fn test_bash_vim_banner_already_shown() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// The banner has already been shown and dismissed.
VimBannerSettings::handle(&app).update(&mut app, |banner_settings, ctx| {
let _ = banner_settings
.vim_keybindings_banner_state
.set_value(BannerState::Dismissed, ctx);
});
// Ensure Warp's vim keybindings are off.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(false, ctx);
});
// Bootstrap a bash session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "bash".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "bash".to_owned(),
shell_options: Some(HashSet::from(["vi_mode".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// Since the user already dismissed the banner, it should not
// be shown again.
terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_none()
}),
"Banner should not have opened"
);
})
}
#[test]
fn test_bash_vim_banner_on() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// Ensure the banner has never been shown.
VimBannerSettings::handle(&app).update(&mut app, |banner_settings, ctx| {
let _ = banner_settings
.vim_keybindings_banner_state
.set_value(BannerState::NotDismissed, ctx);
});
// Ensure Warp's vim keybindings are off.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(false, ctx);
});
// Bootstrap a bash session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "bash".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "bash".to_owned(),
shell_options: Some(HashSet::from(["vi_mode".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// The vim keybinding banner should display.
200 => terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_some()
}),
"Banner did not open in time"
);
})
}
#[test]
fn test_bash_vim_banner_off() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// Ensure the banner has never been shown.
VimBannerSettings::handle(&app).update(&mut app, |banner_settings, ctx| {
let _ = banner_settings
.vim_keybindings_banner_state
.set_value(BannerState::NotDismissed, ctx);
});
// Ensure Warp's vim keybindings are on.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(true, ctx);
});
// Bootstrap a bash session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "bash".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "bash".to_owned(),
shell_options: Some(HashSet::from(["vi_mode".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// The vim keybinding banner should NOT display
// because the user already has vim keybindings turned on.
terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_none()
}),
"Banner should not have opened"
);
})
}
#[test]
fn test_zsh_vim_banner_on() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// Ensure the banner has never been shown.
VimBannerSettings::handle(&app).update(&mut app, |banner_settings, ctx| {
let _ = banner_settings
.vim_keybindings_banner_state
.set_value(BannerState::NotDismissed, ctx);
});
// Ensure Warp's vim keybindings are off.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(false, ctx);
});
// Bootstrap a zsh session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "zsh".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "zsh".to_owned(),
shell_plugins: Some(HashSet::from(["vi".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// The vim keybinding banner should display.
200 => terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_some()
}),
"Banner did not open in time"
);
})
}
#[test]
fn test_zsh_vim_banner_off() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// Ensure the banner has never been shown.
VimBannerSettings::handle(&app).update(&mut app, |banner_settings, ctx| {
let _ = banner_settings
.vim_keybindings_banner_state
.set_value(BannerState::NotDismissed, ctx);
});
// Ensure Warp's vim keybindings are on.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(true, ctx);
});
// Bootstrap a zsh session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "zsh".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "zsh".to_owned(),
shell_plugins: Some(HashSet::from(["vi".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// The vim keybinding banner should NOT display
// because the user already has vim keybindings turned on.
terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_none()
}),
"Banner should not have opened"
);
})
}
#[test]
fn test_fish_vim_banner_on() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// Ensure Warp's vim keybindings are off.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(false, ctx);
});
// Bootstrap a fish session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "fish".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "fish".to_owned(),
shell_options: Some(HashSet::from(["vi_mode".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// The vim keybinding banner should display.
200 => terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_some()
}),
"Banner did not open in time"
);
})
}
#[test]
fn test_fish_vim_banner_off() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal =
MockTerminalManager::create_new_terminal_view_window_for_test(&mut app, None);
// Ensure the terminal is the active session.
terminal.update(&mut app, |view, ctx| {
let terminal_pane_id = TerminalPaneId::dummy_terminal_pane_id();
let focus_state = ctx.add_model(|_| {
PaneGroupFocusState::new(terminal_pane_id.into(), Some(terminal_pane_id), false)
});
let focus_handle = PaneFocusHandle::new(terminal_pane_id.into(), focus_state);
view.set_focus_handle(focus_handle, ctx);
});
// Ensure Warp's vim keybindings are on.
AppEditorSettings::handle(&app).update(&mut app, |editor_settings, ctx| {
let _ = editor_settings.vim_mode.set_value(true, ctx);
});
// Bootstrap a fish session with vi mode enabled.
terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "fish".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "fish".to_owned(),
shell_options: Some(HashSet::from(["vi_mode".to_string()])),
..Default::default()
});
});
// This is asynchronous because we're waiting for the bootstrap event
// to be sent from the terminal model to the terminal view.
assert_eventually!(
// The vim keybinding banner should NOT display
// because the user already has vim keybindings turned on.
terminal.read(&app, |terminal, _terminal_ctx| {
terminal.inline_banners_state.vim_banner_state.is_none()
}),
"Banner should not have opened"
);
})
}
#[test]
fn test_prompt_context_menu_items_for_ps1() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
SessionSettings::handle(&app).update(&mut app, |session_settings, ctx| {
let _ = session_settings.honor_ps1.set_value(true, ctx);
});
terminal.read(&app, |view, ctx| {
let items = view.prompt_context_menu_items(ctx);
let len = items.len();
assert_eq!(len, 3);
assert_eq!(items[0].fields().unwrap().label(), "Copy prompt");
assert!(items[1].is_separator());
assert_eq!(items[2].fields().unwrap().label(), "Edit prompt");
assert!(!items[2].fields().unwrap().is_disabled());
});
})
}
#[test]
fn test_prompt_context_menu_items_for_context_chips() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let model = view.model.lock();
view.current_prompt.update(ctx, |prompt, ctx| {
let PromptType::Dynamic { prompt } = prompt else {
return;
};
prompt.update(ctx, |prompt, ctx| {
prompt.update_context(model.block_list().active_block(), ctx)
});
})
});
// Set the prompt to something we can actually read for.
let prompt = Prompt::handle(&app);
prompt.update(&mut app, |prompt, ctx| {
prompt
.update(
[ContextChipKind::Time12],
false,
WarpPromptSeparator::None,
ctx,
)
.expect("updating prompt to time chip failed");
});
let session_settings = SessionSettings::handle(&app);
session_settings.update(&mut app, |settings, ctx| {
// Force a toggle so the change event fires.
let _ = settings.honor_ps1.set_value(true, ctx);
let _ = settings.honor_ps1.set_value(false, ctx);
});
terminal.read(&app, |view, ctx| {
let items: Vec<MenuItem<TerminalAction>> = view.prompt_context_menu_items(ctx);
assert_eq!(items.len(), 5);
// We expect the prompt menu items to be something like the following when context chips are used:
// Copy prompt
// ------------
// <context chip specific actions>
// ------------
// Edit prompt
assert_eq!(items[0].fields().unwrap().label(), "Copy prompt");
assert!(items[1].is_separator());
assert_eq!(
items[2].fields().unwrap().label(),
"Copy Time (12-hour format)"
);
assert!(items[3].is_separator());
assert_eq!(items[4].fields().unwrap().label(), "Edit prompt");
assert!(!items[4].fields().unwrap().is_disabled());
});
})
}
#[test]
fn test_prompt_context_menu_items_for_no_context_chips() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let model = view.model.lock();
view.current_prompt.update(ctx, |prompt, ctx| {
let PromptType::Dynamic { prompt } = prompt else {
return;
};
prompt.update(ctx, |prompt, ctx| {
prompt.update_context(model.block_list().active_block(), ctx)
});
})
});
let session_settings = SessionSettings::handle(&app);
session_settings.update(&mut app, |settings, ctx| {
let _ = settings.honor_ps1.set_value(false, ctx);
});
terminal.read(&app, |view, ctx| {
let items: Vec<MenuItem<TerminalAction>> = view.prompt_context_menu_items(ctx);
assert_eq!(items.len(), 3);
// We expect the prompt menu items to be something like the following when no context chips exist:
// Copy prompt
// ------------
// Edit prompt
assert_eq!(items[0].fields().unwrap().label(), "Copy prompt");
assert!(items[1].is_separator());
assert_eq!(items[2].fields().unwrap().label(), "Edit prompt");
assert!(!items[2].fields().unwrap().is_disabled());
});
})
}
#[test]
fn test_prompt_context_menu_items_for_agent_toolbelt_flag() {
let _agent_view_guard = FeatureFlag::AgentView.override_enabled(true);
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view");
});
});
{
let _agent_footer_guard = FeatureFlag::AgentToolbarEditor.override_enabled(false);
terminal.read(&app, |view, ctx| {
let items = view.prompt_context_menu_items(ctx);
let labels = items
.iter()
.filter_map(|item| item.fields().map(|fields| fields.label()))
.collect::<Vec<_>>();
assert!(!labels.contains(&"Edit prompt"));
assert!(!labels.contains(&"Edit agent toolbelt"));
});
}
{
let _agent_footer_guard = FeatureFlag::AgentToolbarEditor.override_enabled(true);
terminal.read(&app, |view, ctx| {
let items = view.prompt_context_menu_items(ctx);
let labels = items
.iter()
.filter_map(|item| item.fields().map(|fields| fields.label()))
.collect::<Vec<_>>();
assert!(!labels.contains(&"Edit prompt"));
assert!(labels.contains(&"Edit agent toolbelt"));
});
}
})
}
#[test]
fn agent_footer_updates_chip_groups_when_side_assignment_changes() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let model = view.model.lock();
view.current_prompt.update(ctx, |prompt, ctx| {
let PromptType::Dynamic { prompt } = prompt else {
return;
};
prompt.update(ctx, |prompt, ctx| {
prompt.update_context(model.block_list().active_block(), ctx);
});
});
});
SessionSettings::handle(&app).update(&mut app, |settings, ctx| {
let _ = settings.agent_footer_chip_selection.set_value(
AgentToolbarChipSelection::Custom {
left: vec![AgentToolbarItemKind::ContextChip(ContextChipKind::Time12)],
right: vec![AgentToolbarItemKind::ContextChip(ContextChipKind::Time24)],
},
ctx,
);
});
assert_eventually!(
terminal.read(&app, |view, ctx| {
view.input().as_ref(ctx).agent_footer_chip_kinds(ctx)
== (vec![ContextChipKind::Time12], vec![ContextChipKind::Time24])
}),
"Agent footer should render separate left and right chip groups"
);
SessionSettings::handle(&app).update(&mut app, |settings, ctx| {
let _ = settings.agent_footer_chip_selection.set_value(
AgentToolbarChipSelection::Custom {
left: vec![
AgentToolbarItemKind::ContextChip(ContextChipKind::Time12),
AgentToolbarItemKind::ContextChip(ContextChipKind::Time24),
],
right: vec![],
},
ctx,
);
});
assert_eventually!(
terminal.read(&app, |view, ctx| {
view.input().as_ref(ctx).agent_footer_chip_kinds(ctx)
== (
vec![ContextChipKind::Time12, ContextChipKind::Time24],
vec![],
)
}),
"Agent footer should update when a chip moves between sides without changing overall chip order"
);
})
}
#[test]
fn test_link_at_range_trims_zero_width_spaces() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// NOTE: this has two zero-width spaces, one after the '(', and one before the ')'
let input_url = "(\u{200b}https://warp.dev\u{200b})";
// NOTE: the final character in this string is a zero-width space
let non_escaped_url = "https://warp.dev\u{200b}";
let escaped_url = "https://warp.dev";
terminal.update(&mut app, |view, _ctx| {
view.model.lock().simulate_block(
r"printf '(%bhttps://warp.dev%b)\n' '\U200b' '\U200b'",
input_url,
);
});
terminal.read(&app, |view, ctx| {
let model = view.model.lock();
let block = view
.viewport_state(model.block_list(), InputMode::PinnedToBottom, ctx)
.iter()
.next()
.expect("blocklist should have at least one item");
let point = WithinModel::BlockList(WithinBlock::new(
// I picked the point 0, 4 b/c it seemed to work. It's not clear to me
// why 4 works when numbers like 9 do not. Either way, this is just to
// get the actual url out (passing 9 fails on url_at_point), and does
// not matter for testing link_at_range.
Point::new(0, 4),
block.block_index.expect("block index should exist"),
crate::terminal::GridType::Output,
));
let url = model
.url_at_point(&point)
.expect("url at the designated point should exist");
// Assert that string_at_range preserves the ZW Space
assert_eq!(
model.string_at_range(&url, RespectObfuscatedSecrets::No),
non_escaped_url
);
// Assert that link_at_range removes the ZW Space
assert_eq!(
model.link_at_range(&url, RespectObfuscatedSecrets::No),
escaped_url
);
});
})
}
#[test]
fn test_scroll_position_doesnt_change_when_block_finished() {
use futures_lite::StreamExt;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
let (tx, rx) = async_channel::bounded(1);
app.update(|ctx| {
ctx.subscribe_to_view(&terminal, move |_, event, _| {
if let Event::BlockCompleted { block, .. } = event {
let output = std::str::from_utf8(&block.stylized_output).unwrap();
if output.trim() == "lr" {
tx.try_send(()).expect("Can send over channel");
}
}
});
});
let scroll_position_before_finished = terminal.update(&mut app, |view, ctx| {
// Finish a lengthy block.
view.model.lock().simulate_block("ls", &"\n".repeat(1000));
assert!(view.is_vertically_scrollable(ctx));
assert_eq!(
view.scroll_position(),
ScrollPosition::FollowsBottomOfMostRecentBlock
);
// Start long-running block.
view.model.lock().simulate_long_running_block("", "lr");
// Before the block is finished, scroll up.
view.scroll(1.0.into_lines(), ctx);
let scroll_position_before_finished = view.scroll_position();
assert!(matches!(
scroll_position_before_finished,
ScrollPosition::FixedAtPosition { .. }
));
// Finish the block.
view.model.lock().finish_block();
scroll_position_before_finished
});
// Wait until the terminal view acknowledges the block as completed.
assert!(pin!(rx).next().await.is_some());
// Make sure the scroll position is unchanged when the block finishes.
terminal.read(&app, |view, _| {
let scroll_position_after_finished = view.scroll_position();
assert_eq!(
scroll_position_before_finished,
scroll_position_after_finished
);
});
})
}
#[test]
fn inline_agent_view_exits_when_tagged_in_long_running_command_is_tagged_out() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "zsh".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "zsh".to_owned(),
..Default::default()
});
model.simulate_long_running_block("sleep 10", "running");
}
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_inline_agent_view(
None,
AgentViewEntryOrigin::LongRunningCommand,
ctx,
)
.expect("should enter inline agent view for a tagged-in command");
});
view.model
.lock()
.block_list_mut()
.active_block_mut()
.set_is_agent_tagged_in(true);
assert!(view.agent_view_controller().as_ref(ctx).is_inline());
assert!(view
.model
.lock()
.block_list()
.active_block()
.is_agent_tagged_in());
let model = view.model.lock();
assert!(view.is_input_box_visible(&model, ctx));
drop(model);
view.handle_action(&TerminalAction::SetInputModeTerminal, ctx);
assert!(!view.agent_view_controller().as_ref(ctx).is_active());
let model = view.model.lock();
let active_block = model.block_list().active_block();
assert!(!active_block.is_agent_tagged_in());
assert!(!view.is_input_box_visible(&model, ctx));
});
})
}
#[test]
fn inline_agent_view_persists_across_transfer_takeover_for_monitored_long_running_command() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "zsh".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "zsh".to_owned(),
..Default::default()
});
model.simulate_long_running_block("ssh localhost", "Password:");
}
let conversation_id = view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_inline_agent_view(
None,
AgentViewEntryOrigin::LongRunningCommand,
ctx,
)
.expect("inline agent view should create a conversation")
});
view.model
.lock()
.block_list_mut()
.active_block_mut()
.set_is_agent_tagged_in(true);
let task_id = TaskId::new("test-task".to_owned());
view.model
.lock()
.block_list_mut()
.active_block_mut()
.set_agent_interaction_mode_for_agent_monitored_command(&task_id, conversation_id)
.expect("tagged-in command should transition to agent-monitored");
assert!(view.agent_view_controller().as_ref(ctx).is_inline());
let model = view.model.lock();
assert!(model.block_list().active_block().is_agent_in_control());
assert!(view.is_input_box_visible(&model, ctx));
drop(model);
view.cli_subagent_controller.update(ctx, |controller, ctx| {
controller.switch_control_to_user(
UserTakeOverReason::TransferFromAgent {
reason: "Enter your password".to_owned(),
},
ctx,
);
});
assert!(view.agent_view_controller().as_ref(ctx).is_inline());
let model = view.model.lock();
let active_block = model.block_list().active_block();
assert!(active_block.is_eligible_for_agent_handoff());
assert!(!view.is_input_box_visible(&model, ctx));
drop(model);
view.cli_subagent_controller.update(ctx, |controller, ctx| {
controller.handoff_active_command_control_to_agent(ctx);
});
assert!(view.agent_view_controller().as_ref(ctx).is_inline());
let model = view.model.lock();
let active_block = model.block_list().active_block();
assert!(active_block.is_agent_in_control());
assert!(view.is_input_box_visible(&model, ctx));
});
})
}
#[test]
fn use_agent_footer_renders_for_transfer_handoff_even_when_user_command_footer_setting_disabled() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
AISettings::handle(&app).update(&mut app, |settings, ctx| {
let _ = settings
.should_render_use_agent_footer_for_user_commands
.set_value(false, ctx);
});
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
{
let mut model = view.model.lock();
model.init_shell(InitShellValue {
session_id: 0.into(),
shell: "zsh".to_owned(),
..Default::default()
});
model.bootstrapped(BootstrappedValue {
shell: "zsh".to_owned(),
..Default::default()
});
model.simulate_long_running_block("ssh localhost", "Password:");
}
view.maybe_show_use_agent_footer_in_blocklist(ctx);
{
let model = view.model.lock();
assert!(!view.should_render_use_agent_footer(&model, ctx));
let active_block_index = model.block_list().active_block_index();
assert!(model
.block_list()
.last_non_hidden_rich_content_block_after_block(Some(active_block_index))
.is_none());
}
let conversation_id = view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_inline_agent_view(
None,
AgentViewEntryOrigin::LongRunningCommand,
ctx,
)
.expect("inline agent view should create a conversation")
});
view.model
.lock()
.block_list_mut()
.active_block_mut()
.set_is_agent_tagged_in(true);
let task_id = TaskId::new("test-task".to_owned());
view.model
.lock()
.block_list_mut()
.active_block_mut()
.set_agent_interaction_mode_for_agent_monitored_command(&task_id, conversation_id)
.expect("tagged-in command should transition to agent-monitored");
view.cli_subagent_controller.update(ctx, |controller, ctx| {
controller.switch_control_to_user(
UserTakeOverReason::TransferFromAgent {
reason: "Enter your password".to_owned(),
},
ctx,
);
});
view.maybe_show_use_agent_footer_in_blocklist(ctx);
let model = view.model.lock();
assert!(view.should_render_use_agent_footer(&model, ctx));
let active_block_index = model.block_list().active_block_index();
let rendered_footer_view_id = model
.block_list()
.last_non_hidden_rich_content_block_after_block(Some(active_block_index))
.map(|(_, item)| item.view_id);
assert_eq!(rendered_footer_view_id, Some(view.use_agent_footer.id()));
});
})
}
#[test]
fn test_first_onboarding_block_exists() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Testing the onboarding sequence with Settings Import disabled.
FeatureFlag::SettingsImport.set_enabled(false);
terminal.update(&mut app, |terminal_view, ctx| {
terminal_view.handle_action(
&TerminalAction::OnboardingFlow(OnboardingVersion::Legacy),
ctx,
);
});
terminal.update(&mut app, |terminal_view, ctx| {
assert!(terminal_view.block_onboarding_active);
// Here we assert that Agentic Suggestions block is the first one. As we modify the sequence, this test will have to be updated.
ctx.subscribe_to_model(&History::handle(ctx), move |me, _, event, _| match event {
HistoryEvent::Initialized(_) => {
assert!(me.onboarding_agentic_suggestions_block.is_some());
}
});
});
})
}
#[test]
fn exiting_agent_view_removes_empty_conversations() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
// Enter agent view (creates new conversation)
let conversation_id = terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
})
});
// Entering agent view without specifying a conversation creates a new conversation.
let exists_before_exit = BlocklistAIHistoryModel::handle(&app).read(&app, |history, _| {
history
.conversation(&conversation_id)
.is_some_and(|c| c.exchange_count() == 0)
});
assert!(exists_before_exit);
// Sanity: conversation exists but has no exchanges.
terminal.update(&mut app, |view, ctx| {
view.agent_view_controller()
.update(ctx, |controller, ctx| controller.exit_agent_view(ctx))
});
// Exiting agent view should remove the empty conversation.
let exists_after_exit = BlocklistAIHistoryModel::handle(&app).read(&app, |history, _| {
history.conversation(&conversation_id).is_some()
});
assert!(!exists_after_exit);
})
}
#[test]
fn ctrl_c_exit_agent_view_requires_confirmation() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
// Enter agent view (creates new conversation)
terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
})
});
// First ctrl-c should arm confirmation but not exit.
terminal.update(&mut app, |view, ctx| {
assert!(view.agent_view_controller().as_ref(ctx).is_active());
view.handle_input_event(
&InputEvent::CtrlC {
cleared_buffer_len: 0,
},
ctx,
);
assert!(view.agent_view_controller().as_ref(ctx).is_active());
});
// Second ctrl-c should confirm and exit.
terminal.update(&mut app, |view, ctx| {
view.handle_input_event(
&InputEvent::CtrlC {
cleared_buffer_len: 0,
},
ctx,
);
assert!(!view.agent_view_controller().as_ref(ctx).is_active());
});
})
}
#[test]
fn ctrl_c_buffer_clear_then_exit_requires_three_presses_in_agent_view() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
})
});
// 1st ctrl-c clears input buffer (simulated) and should not trigger cancel/exit.
terminal.update(&mut app, |view, ctx| {
assert!(view.agent_view_controller().as_ref(ctx).is_active());
view.handle_input_event(
&InputEvent::CtrlC {
cleared_buffer_len: 5,
},
ctx,
);
assert!(view.agent_view_controller().as_ref(ctx).is_active());
});
// 2nd ctrl-c arms exit confirmation.
terminal.update(&mut app, |view, ctx| {
view.handle_input_event(
&InputEvent::CtrlC {
cleared_buffer_len: 0,
},
ctx,
);
assert!(view.agent_view_controller().as_ref(ctx).is_active());
});
// 3rd ctrl-c confirms and exits.
terminal.update(&mut app, |view, ctx| {
view.handle_input_event(
&InputEvent::CtrlC {
cleared_buffer_len: 0,
},
ctx,
);
assert!(!view.agent_view_controller().as_ref(ctx).is_active());
});
})
}
#[test]
fn terminal_action_ctrl_c_exit_agent_view_requires_confirmation() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
})
});
terminal.update(&mut app, |view, ctx| {
assert!(view.agent_view_controller().as_ref(ctx).is_active());
view.handle_action(&TerminalAction::CtrlC, ctx);
assert!(view.agent_view_controller().as_ref(ctx).is_active());
});
terminal.update(&mut app, |view, ctx| {
view.handle_action(&TerminalAction::CtrlC, ctx);
assert!(!view.agent_view_controller().as_ref(ctx).is_active());
});
})
}
/// Sets up a CLI agent session, opens rich input, submits `text`, and returns
/// the terminal handle and the collected PTY writes.
#[allow(clippy::type_complexity)]
fn submit_rich_input_and_collect_pty_writes(
app: &mut App,
agent: CLIAgent,
text: &str,
) -> (ViewHandle<TerminalView>, Rc<RefCell<Vec<Vec<u8>>>>) {
let terminal = add_window_with_terminal(app, None);
let pty_writes: Rc<RefCell<Vec<Vec<u8>>>> = Rc::new(RefCell::new(Vec::new()));
let writes = pty_writes.clone();
app.update(|ctx| {
ctx.subscribe_to_view(&terminal, move |_, event, _| {
if let Event::WriteBytesToPty { bytes } = event {
writes.borrow_mut().push(bytes.to_vec());
}
});
});
terminal.update(app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: false,
listener: None,
remote_host: None,
plugin_version: None,
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
view.submit_cli_agent_rich_input(text.to_owned(), ctx);
});
(terminal, pty_writes)
}
fn open_cli_agent_rich_input_for_agent(app: &mut App, agent: CLIAgent) -> ViewHandle<TerminalView> {
let terminal = add_window_with_terminal(app, None);
terminal.update(app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: false,
listener: None,
remote_host: None,
plugin_version: None,
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
});
terminal
}
#[test]
fn cli_agent_rich_input_hint_text_mentions_active_cli_agent() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
for (agent, expected_hint_text) in [
(CLIAgent::Claude, "Enter prompt for Claude Code..."),
(CLIAgent::Gemini, "Enter prompt for Gemini..."),
(CLIAgent::Codex, "Enter prompt for Codex..."),
(CLIAgent::Unknown, "Tell the agent what to build..."),
] {
let terminal = open_cli_agent_rich_input_for_agent(&mut app, agent);
terminal.read(&app, |view, ctx| {
let placeholder_text = view
.input
.as_ref(ctx)
.editor()
.as_ref(ctx)
.placeholder_text("");
assert_eq!(placeholder_text, Some(expected_hint_text));
});
}
})
}
#[test]
fn cli_agent_rich_input_shell_mode_uses_run_commands_hint_text() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let terminal = open_cli_agent_rich_input_for_agent(&mut app, CLIAgent::Claude);
terminal.update(&mut app, |view, ctx| {
view.input.update(ctx, |input, ctx| {
input.ai_input_model().update(ctx, |ai_input, ctx| {
ai_input.set_input_config(
InputConfig {
input_type: InputType::Shell,
is_locked: true,
},
true,
ctx,
);
});
input.set_zero_state_hint_text(ctx);
});
});
terminal.read(&app, |view, ctx| {
let placeholder_text = view
.input
.as_ref(ctx)
.editor()
.as_ref(ctx)
.placeholder_text("");
assert_eq!(placeholder_text, Some("Run commands"));
});
})
}
#[test]
fn submit_cli_agent_rich_input_codex_uses_bracketed_paste() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let (_terminal, pty_writes) =
submit_rich_input_and_collect_pty_writes(&mut app, CLIAgent::Codex, "hello");
let writes = pty_writes.borrow();
// BracketedPaste: first write is ESC[200~ + text + ESC[201~, second is \r.
assert_eq!(
writes.len(),
2,
"expected 2 PTY writes, got {}",
writes.len()
);
let mut expected_paste =
Vec::with_capacity(BRACKETED_PASTE_START.len() + 5 + BRACKETED_PASTE_END.len());
expected_paste.extend_from_slice(BRACKETED_PASTE_START);
expected_paste.extend_from_slice(b"hello");
expected_paste.extend_from_slice(BRACKETED_PASTE_END);
assert_eq!(writes[0], expected_paste);
assert_eq!(writes[1], b"\r");
})
}
#[test]
fn submit_cli_agent_rich_input_opencode_defers_enter_and_close() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let (_terminal, pty_writes) =
submit_rich_input_and_collect_pty_writes(&mut app, CLIAgent::OpenCode, "hello");
// Immediately after submit, only the text should have been written;
// the \r is sent after a short delay.
assert_eq!(pty_writes.borrow().len(), 1);
assert_eq!(pty_writes.borrow()[0], b"hello");
// Wait for the delayed \r to arrive.
assert_eventually!(
pty_writes.borrow().len() == 2,
"carriage return should be written after delay"
);
assert_eq!(pty_writes.borrow()[1], b"\r");
})
}
#[test]
fn submit_without_auto_dismiss_keeps_rich_input_open() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
// auto_dismiss defaults to false — leave it off.
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: false,
listener: None,
remote_host: None,
plugin_version: None,
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
view.submit_cli_agent_rich_input("hello".to_owned(), ctx);
// Rich input stays open because auto_dismiss is off.
assert!(view.has_active_cli_agent_input_session(ctx));
});
// Buffer should still be cleared even though rich input is open.
terminal.read(&app, |view, ctx| {
let input = view.input.as_ref(ctx);
assert!(input.editor().as_ref(ctx).buffer_text(ctx).is_empty());
});
})
}
#[test]
fn submit_with_plugin_and_auto_toggle_keeps_rich_input_open() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
// auto_toggle_rich_input defaults to true.
// Turn on auto_dismiss too — it should be overridden by auto_toggle.
AISettings::handle(&app).update(&mut app, |settings, ctx| {
let _ = settings
.auto_dismiss_rich_input_after_submit
.set_value(true, ctx);
});
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
// Create a session with a plugin listener and should_auto_toggle_input.
let listener = ctx.add_model(|ctx| {
CLIAgentSessionListener::new(
view.view_id,
CLIAgent::Claude,
&view.model_events_handle,
ctx,
)
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: true,
listener: Some(listener),
remote_host: None,
plugin_version: Some("1.0.0".to_owned()),
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
view.submit_cli_agent_rich_input("hello".to_owned(), ctx);
// Rich input stays open because auto_toggle + plugin takes precedence.
assert!(view.has_active_cli_agent_input_session(ctx));
});
})
}
#[test]
fn submit_with_plugin_but_auto_toggle_off_respects_auto_dismiss() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
AISettings::handle(&app).update(&mut app, |settings, ctx| {
let _ = settings.auto_toggle_rich_input.set_value(false, ctx);
let _ = settings
.auto_dismiss_rich_input_after_submit
.set_value(true, ctx);
});
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let listener = ctx.add_model(|ctx| {
CLIAgentSessionListener::new(
view.view_id,
CLIAgent::Claude,
&view.model_events_handle,
ctx,
)
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: true,
listener: Some(listener),
remote_host: None,
plugin_version: Some("1.0.0".to_owned()),
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
view.submit_cli_agent_rich_input("hello".to_owned(), ctx);
});
// auto_toggle is off, so auto_dismiss closes rich input.
// Claude uses DelayedEnter, so the close happens after a timer.
assert_eventually!(
terminal.read(&app, |view, ctx| !view
.has_active_cli_agent_input_session(ctx)),
"Rich input should be closed after submit with auto_dismiss"
);
})
}
#[test]
fn status_blocked_auto_closes_rich_input() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
// auto_toggle_rich_input defaults to true.
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let listener = ctx.add_model(|ctx| {
CLIAgentSessionListener::new(
view.view_id,
CLIAgent::Claude,
&view.model_events_handle,
ctx,
)
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: true,
listener: Some(listener),
remote_host: None,
plugin_version: Some("1.0.0".to_owned()),
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
// Simulate a PermissionRequest event → status transitions to Blocked.
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionRequest,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload {
summary: Some("Approve?".to_owned()),
..Default::default()
},
},
ctx,
);
});
});
// The StatusChanged event is delivered to the terminal view, which
// auto-closes rich input because the agent is blocked.
terminal.read(&app, |view, ctx| {
assert!(!view.has_active_cli_agent_input_session(ctx));
});
// should_auto_toggle_input is preserved so auto-open can fire later.
terminal.read(&app, |_view, ctx| {
let session = CLIAgentSessionsModel::as_ref(ctx).session(_view.view_id);
assert!(session.unwrap().should_auto_toggle_input);
});
})
}
#[test]
fn status_in_progress_auto_opens_rich_input_after_blocked() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let listener = ctx.add_model(|ctx| {
CLIAgentSessionListener::new(
view.view_id,
CLIAgent::Claude,
&view.model_events_handle,
ctx,
)
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: true,
listener: Some(listener),
remote_host: None,
plugin_version: Some("1.0.0".to_owned()),
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
// Open rich input, then simulate blocked → closed automatically.
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionRequest,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload {
summary: Some("Approve?".to_owned()),
..Default::default()
},
},
ctx,
);
});
});
// Rich input should be auto-closed from the blocked status.
terminal.read(&app, |view, ctx| {
assert!(!view.has_active_cli_agent_input_session(ctx));
});
// Simulate permission replied → status transitions back to InProgress.
terminal.update(&mut app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionReplied,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload::default(),
},
ctx,
);
});
});
// Rich input should auto-open because should_auto_toggle_input was preserved.
terminal.read(&app, |view, ctx| {
assert!(view.has_active_cli_agent_input_session(ctx));
});
})
}
#[test]
fn cli_session_status_updates_active_child_conversation() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
let child_conversation_id = terminal.update(&mut app, |view, ctx| {
let parent_conversation_id =
BlocklistAIHistoryModel::handle(ctx).update(ctx, |history_model, ctx| {
history_model.start_new_conversation(view.view_id, false, false, ctx)
});
let child_conversation_id =
BlocklistAIHistoryModel::handle(ctx).update(ctx, |history_model, ctx| {
history_model.start_new_child_conversation(
view.view_id,
"Agent 2".to_string(),
parent_conversation_id,
ctx,
)
});
view.enter_agent_view(
None,
Some(child_conversation_id),
AgentViewEntryOrigin::ChildAgent,
ctx,
);
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: false,
listener: None,
remote_host: None,
plugin_version: None,
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
child_conversation_id
});
terminal.read(&app, |_view, ctx| {
let conversation = BlocklistAIHistoryModel::as_ref(ctx)
.conversation(&child_conversation_id)
.expect("child conversation should exist");
assert_eq!(conversation.status(), &ConversationStatus::InProgress);
});
terminal.update(&mut app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionRequest,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload {
summary: Some("Approve?".to_owned()),
..Default::default()
},
},
ctx,
);
});
});
terminal.read(&app, |_view, ctx| {
let conversation = BlocklistAIHistoryModel::as_ref(ctx)
.conversation(&child_conversation_id)
.expect("child conversation should exist");
assert_eq!(
conversation.status(),
&ConversationStatus::Blocked {
blocked_action: "Approve?".to_string(),
}
);
});
terminal.update(&mut app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionReplied,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload::default(),
},
ctx,
);
});
});
terminal.read(&app, |_view, ctx| {
let conversation = BlocklistAIHistoryModel::as_ref(ctx)
.conversation(&child_conversation_id)
.expect("child conversation should exist");
assert_eq!(conversation.status(), &ConversationStatus::InProgress);
});
terminal.update(&mut app, |view, ctx| {
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::Stop,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload {
response: Some("Done".to_owned()),
..Default::default()
},
},
ctx,
);
});
});
terminal.read(&app, |_view, ctx| {
let conversation = BlocklistAIHistoryModel::as_ref(ctx)
.conversation(&child_conversation_id)
.expect("child conversation should exist");
assert_eq!(conversation.status(), &ConversationStatus::Success);
});
})
}
#[test]
fn manual_dismiss_disables_auto_toggle_for_session() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
let listener = ctx.add_model(|ctx| {
CLIAgentSessionListener::new(
view.view_id,
CLIAgent::Claude,
&view.model_events_handle,
ctx,
)
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.set_session(
view.view_id,
CLIAgentSession {
agent: CLIAgent::Claude,
status: CLIAgentSessionStatus::InProgress,
session_context: CLIAgentSessionContext::default(),
input_state: CLIAgentInputState::Closed,
should_auto_toggle_input: true,
listener: Some(listener),
remote_host: None,
plugin_version: Some("1.0.0".to_owned()),
draft_text: None,
custom_command_prefix: None,
},
ctx,
);
});
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
// Manual dismiss via the "disable auto-toggle" path (Escape / Ctrl-G / footer).
view.close_cli_agent_rich_input_and_disable_auto_toggle(ctx);
assert!(!view.has_active_cli_agent_input_session(ctx));
});
// should_auto_toggle_input should now be false.
terminal.read(&app, |view, ctx| {
let session = CLIAgentSessionsModel::as_ref(ctx).session(view.view_id);
assert!(!session.unwrap().should_auto_toggle_input);
});
// A status change to InProgress should NOT auto-open rich input.
terminal.update(&mut app, |view, ctx| {
// First move to Blocked so we can transition back.
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionRequest,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload {
summary: Some("Approve?".to_owned()),
..Default::default()
},
},
ctx,
);
});
CLIAgentSessionsModel::handle(ctx).update(ctx, |sessions, ctx| {
sessions.update_from_event(
view.view_id,
&CLIAgentEvent {
v: 1,
agent: CLIAgent::Claude,
event: CLIAgentEventType::PermissionReplied,
session_id: None,
cwd: None,
project: None,
payload: CLIAgentEventPayload::default(),
},
ctx,
);
});
});
// Rich input should remain closed.
terminal.read(&app, |view, ctx| {
assert!(!view.has_active_cli_agent_input_session(ctx));
});
})
}
#[test]
fn close_cli_agent_rich_input_saves_draft_and_reopen_restores_it() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let terminal = open_cli_agent_rich_input_for_agent(&mut app, CLIAgent::Claude);
// Type some text into the composer.
terminal.update(&mut app, |view, ctx| {
view.input.update(ctx, |input, ctx| {
input.replace_buffer_content("work in progress", ctx);
});
});
// Close the composer — the buffer text should be saved as a draft.
terminal.update(&mut app, |view, ctx| {
view.close_cli_agent_rich_input(CLIAgentRichInputCloseReason::Manual, ctx);
assert!(!view.has_active_cli_agent_input_session(ctx));
});
terminal.read(&app, |view, ctx| {
let session = CLIAgentSessionsModel::as_ref(ctx)
.session(view.view_id)
.expect("session should exist");
assert_eq!(
session.draft_text.as_deref(),
Some("work in progress"),
"draft should be saved on close"
);
});
// Reopen — draft should be restored into the buffer and consumed.
terminal.update(&mut app, |view, ctx| {
view.open_cli_agent_rich_input(CLIAgentInputEntrypoint::FooterButton, ctx);
assert!(view.has_active_cli_agent_input_session(ctx));
});
terminal.read(&app, |view, ctx| {
assert_eq!(
view.input.as_ref(ctx).buffer_text(ctx),
"work in progress",
"draft should be restored on reopen"
);
let session = CLIAgentSessionsModel::as_ref(ctx)
.session(view.view_id)
.expect("session should exist");
assert_eq!(
session.draft_text, None,
"draft should be consumed after restore"
);
});
})
}
#[test]
fn submit_cli_agent_rich_input_clears_draft() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
AISettings::handle(&app).update(&mut app, |settings, ctx| {
// Keep the input open after submit so we can inspect the buffer.
let _ = settings
.auto_dismiss_rich_input_after_submit
.set_value(false, ctx);
});
let terminal = open_cli_agent_rich_input_for_agent(&mut app, CLIAgent::Claude);
terminal.update(&mut app, |view, ctx| {
view.submit_cli_agent_rich_input("hello agent".to_owned(), ctx);
// Input stays open because auto-dismiss is off.
assert!(view.has_active_cli_agent_input_session(ctx));
});
terminal.read(&app, |view, ctx| {
let session = CLIAgentSessionsModel::as_ref(ctx)
.session(view.view_id)
.expect("session should exist");
assert_eq!(
session.draft_text, None,
"draft should be cleared after submit"
);
assert!(
view.input.as_ref(ctx).buffer_text(ctx).is_empty(),
"buffer should be empty after submit"
);
});
})
}
#[test]
fn close_cli_agent_rich_input_with_empty_buffer_stores_no_draft() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let _agent_view = FeatureFlag::AgentView.override_enabled(true);
let _cli_rich = FeatureFlag::CLIAgentRichInput.override_enabled(true);
let terminal = open_cli_agent_rich_input_for_agent(&mut app, CLIAgent::Claude);
// Close immediately without typing anything.
terminal.update(&mut app, |view, ctx| {
view.close_cli_agent_rich_input(CLIAgentRichInputCloseReason::Manual, ctx);
assert!(!view.has_active_cli_agent_input_session(ctx));
});
terminal.read(&app, |view, ctx| {
let session = CLIAgentSessionsModel::as_ref(ctx)
.session(view.view_id)
.expect("session should exist");
assert_eq!(
session.draft_text, None,
"no draft should be stored for empty buffer"
);
});
})
}
#[test]
fn ctrl_c_does_not_accept_prompt_suggestion_banner() {
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
let terminal = add_window_with_terminal(&mut app, None);
let block_id = terminal.update(&mut app, |view, _ctx| {
let mut model = view.model.lock();
model.simulate_block("ls", "output");
let last_completed_block_index = BlockIndex(model.block_list().blocks().len() - 2);
model
.block_list()
.block_at(last_completed_block_index)
.unwrap()
.id()
.clone()
});
terminal.update(&mut app, |view, ctx| {
view.on_legacy_prompt_suggestion_generated(
AgentModePromptSuggestion::Success(PromptSuggestion {
id: "suggestion".to_owned(),
label: Some("Do something".to_owned()),
prompt: "Do something".to_owned(),
coding_query_context: None,
static_prompt_suggestion_name: None,
should_start_new_conversation: false,
}),
block_id.clone(),
"ls".to_owned(),
0,
ctx,
);
assert!(view
.inline_banners_state
.prompt_suggestions_banner
.is_some());
// Ctrl-C should not accept the prompt suggestion.
view.handle_action(&TerminalAction::CtrlC, ctx);
assert!(view
.inline_banners_state
.prompt_suggestions_banner
.is_some());
});
})
}
/// Regression test for GH703: a Linear deeplink prompt must never be auto-submitted
/// to the LLM. Because `LinearDeepLink` returns `AutoTriggerBehavior::Never`, the
/// prompt must land in the input buffer as a draft and the "press enter again to
/// send" ephemeral message must be shown so the user can inspect and explicitly
/// send it.
#[test]
fn linear_deeplink_populates_input_as_draft_when_not_in_agent_view() {
use super::agent_view::ENTER_AGAIN_TO_SEND_MESSAGE_ID;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.enter_agent_view_for_new_conversation(
Some("attacker prompt".to_owned()),
AgentViewEntryOrigin::LinearDeepLink,
ctx,
);
});
terminal.read(&app, |view, ctx| {
assert!(
view.agent_view_controller().as_ref(ctx).is_active(),
"Linear deeplink should enter agent view"
);
assert_eq!(
view.input.as_ref(ctx).buffer_text(ctx),
"attacker prompt",
"Linear deeplink prompt should be placed in the input buffer as a draft"
);
let ephemeral_message_id = view
.ephemeral_message_model
.as_ref(ctx)
.current_message()
.and_then(|msg| msg.id().map(|id| id.to_owned()));
assert_eq!(
ephemeral_message_id.as_deref(),
Some(ENTER_AGAIN_TO_SEND_MESSAGE_ID),
"the 'enter again to send' affordance should be shown"
);
});
})
}
/// The critical regression guard for GH703: even when the user is already in
/// fullscreen agent view, a Linear deeplink prompt must not be auto-submitted to
/// the LLM. `LinearDeepLink` returns `AutoTriggerBehavior::Never`, so even the
/// `was_in_agent_view_already` shortcut cannot promote it to auto-submit.
#[test]
fn linear_deeplink_does_not_auto_submit_when_already_in_agent_view() {
use super::agent_view::ENTER_AGAIN_TO_SEND_MESSAGE_ID;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
// First enter fullscreen agent view with no initial prompt. This matches the
// pre-condition in the issue: the focused terminal is already in fullscreen
// agent view when the `warp://linear/work?prompt=...` URI is dispatched.
let original_conversation_id = terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
})
});
terminal.read(&app, |view, ctx| {
assert!(view
.agent_view_controller()
.as_ref(ctx)
.agent_view_state()
.is_fullscreen());
});
// Now dispatch the Linear deeplink while already in fullscreen agent view.
terminal.update(&mut app, |view, ctx| {
view.enter_agent_view_for_new_conversation(
Some("attacker prompt".to_owned()),
AgentViewEntryOrigin::LinearDeepLink,
ctx,
);
});
terminal.read(&app, |view, ctx| {
// A new conversation should have been created for the Linear deeplink.
let new_conversation_id = view
.agent_view_controller()
.as_ref(ctx)
.agent_view_state()
.active_conversation_id()
.expect("agent view should still be active after Linear deeplink entry");
assert_ne!(
new_conversation_id, original_conversation_id,
"Linear deeplink should open a new conversation"
);
// The prompt must be a draft, not auto-submitted.
assert_eq!(
view.input.as_ref(ctx).buffer_text(ctx),
"attacker prompt",
"Linear deeplink prompt must stay as a draft in the input buffer"
);
let ephemeral_message_id = view
.ephemeral_message_model
.as_ref(ctx)
.current_message()
.and_then(|msg| msg.id().map(|id| id.to_owned()));
assert_eq!(
ephemeral_message_id.as_deref(),
Some(ENTER_AGAIN_TO_SEND_MESSAGE_ID),
"the 'enter again to send' affordance must be shown so the user can \
consciously send the Linear-originated prompt"
);
});
})
}
/// `LinearDeepLink` returns `AutoTriggerBehavior::Never`, so it must not
/// auto-submit regardless of prior agent-view state.
#[test]
fn linear_deeplink_via_default_entrypoint_does_not_auto_submit_in_fullscreen() {
use super::agent_view::ENTER_AGAIN_TO_SEND_MESSAGE_ID;
App::test((), |mut app| async move {
initialize_app_for_terminal_view(&mut app);
FeatureFlag::AgentView.set_enabled(true);
let terminal = add_window_with_terminal(&mut app, None);
terminal.update(&mut app, |view, ctx| {
view.agent_view_controller().update(ctx, |controller, ctx| {
controller
.try_enter_agent_view(
None,
AgentViewEntryOrigin::Input {
was_prompt_autodetected: false,
},
ctx,
)
.expect("Should be able to enter agent view")
});
});
terminal.update(&mut app, |view, ctx| {
view.enter_agent_view_for_new_conversation(
Some("attacker prompt".to_owned()),
AgentViewEntryOrigin::LinearDeepLink,
ctx,
);
});
terminal.read(&app, |view, ctx| {
assert_eq!(
view.input.as_ref(ctx).buffer_text(ctx),
"attacker prompt",
"Linear deeplink prompt must not be auto-submitted"
);
let ephemeral_message_id = view
.ephemeral_message_model
.as_ref(ctx)
.current_message()
.and_then(|msg| msg.id().map(|id| id.to_owned()));
assert_eq!(
ephemeral_message_id.as_deref(),
Some(ENTER_AGAIN_TO_SEND_MESSAGE_ID),
);
});
})
}
Reference in New Issue View Git Blame Copy Permalink