public/galaxy
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
4770ac06b5a6219235c288ec3decf449d2054dc6
galaxy/app/src/ai/blocklist/context_model_tests.rs
T

604 lines
21 KiB
Rust
Raw Blame History

//! Unit tests for [`BlocklistAIContextModel`].
//!
//! These tests use [`BlocklistAIContextModel::new_for_test`] and a small conversation-selection
//! fake to avoid unrelated subscriptions while exercising context behavior.
use std::sync::Arc;
use parking_lot::FairMutex;
#[cfg(feature = "local_fs")]
use repo_metadata::DirectoryWatcher;
#[cfg(feature = "local_fs")]
use warp_util::standardized_path::StandardizedPath;
use warpui::r#async::executor::Background;
use warpui::{App, EntityId, ModelHandle, SingletonEntity};
use super::{BlocklistAIContextModel, PendingAttachment, PendingFile};
use crate::ai::agent::conversation::AIConversationId;
use crate::ai::agent::{AIAgentContext, ImageContext};
use crate::ai::blocklist::agent_view::{AgentViewEntryOrigin, EnterAgentViewError};
use crate::ai::blocklist::conversation_selection::{
ConversationSelection, ConversationSelectionEvent,
};
use crate::ai::blocklist::{
BlocklistAIHistoryEvent, BlocklistAIHistoryModel, QueuedQuery, QueuedQueryModel,
QueuedQueryOrigin,
};
#[cfg(feature = "local_fs")]
use crate::code_review::git_repo_model::GitRepoStatusModel;
#[cfg(feature = "local_fs")]
use crate::code_review::github_repo_model::GitHubRepoModel;
use crate::terminal::color::{self, Colors};
use crate::terminal::event_listener::ChannelEventListener;
use crate::terminal::model::test_utils::block_size;
use crate::terminal::model::{BlockId, TerminalModel};
use crate::test_util::settings::initialize_history_persistence_for_tests;
use crate::util::git::{PrInfo, RepositoryInfo};
impl BlocklistAIContextModel {
pub(crate) fn append_pending_attachments_for_test(
&mut self,
attachments: Vec<PendingAttachment>,
) {
self.pending_attachments.extend(attachments);
}
pub(crate) fn insert_pending_block_id_for_test(&mut self, block_id: BlockId) {
self.pending_context_block_ids.insert(block_id);
}
pub(crate) fn set_pending_selected_text_for_test(&mut self, text: Option<String>) {
self.pending_context_selected_text = text;
}
}
struct TestConversationSelection {
terminal_surface_id: EntityId,
selected_conversation_id: Option<AIConversationId>,
}
impl TestConversationSelection {
fn new(
terminal_surface_id: EntityId,
_: &mut warpui::ModelContext<Box<dyn ConversationSelection>>,
) -> Self {
Self {
terminal_surface_id,
selected_conversation_id: None,
}
}
}
impl ConversationSelection for TestConversationSelection {
fn selected_conversation_id(&self, _: &warpui::AppContext) -> Option<AIConversationId> {
self.selected_conversation_id
}
fn is_conversation_active(&self, _: &warpui::AppContext) -> bool {
self.selected_conversation_id.is_some()
}
fn is_conversation_fullscreen(&self, _: &warpui::AppContext) -> bool {
self.selected_conversation_id.is_some()
}
fn select_existing_conversation(
&mut self,
conversation_id: AIConversationId,
_: AgentViewEntryOrigin,
ctx: &mut warpui::ModelContext<Box<dyn ConversationSelection>>,
) {
if self.selected_conversation_id != Some(conversation_id) {
self.selected_conversation_id = Some(conversation_id);
ctx.emit(ConversationSelectionEvent::Changed);
}
}
fn select_new_conversation(
&mut self,
_: AgentViewEntryOrigin,
ctx: &mut warpui::ModelContext<Box<dyn ConversationSelection>>,
) {
if self.selected_conversation_id.take().is_some() {
ctx.emit(ConversationSelectionEvent::Changed);
}
}
fn try_start_new_conversation(
&mut self,
_: AgentViewEntryOrigin,
ctx: &mut warpui::ModelContext<Box<dyn ConversationSelection>>,
) -> Result<AIConversationId, EnterAgentViewError> {
let conversation_id = BlocklistAIHistoryModel::handle(ctx).update(ctx, |history, ctx| {
history.start_new_conversation(self.terminal_surface_id, false, false, false, ctx)
});
self.select_existing_conversation(conversation_id, AgentViewEntryOrigin::Cli, ctx);
Ok(conversation_id)
}
fn pending_query_autoexecute_override(
&self,
app: &warpui::AppContext,
) -> crate::ai::agent::conversation::AIConversationAutoexecuteMode {
self.selected_conversation_id
.as_ref()
.and_then(|conversation_id| {
BlocklistAIHistoryModel::as_ref(app).conversation(conversation_id)
})
.map(|conversation| conversation.autoexecute_override())
.unwrap_or_default()
}
fn toggle_pending_query_autoexecute(
&mut self,
ctx: &mut warpui::ModelContext<Box<dyn ConversationSelection>>,
) {
if let Some(conversation_id) = self.selected_conversation_id {
BlocklistAIHistoryModel::handle(ctx).update(ctx, |history, ctx| {
history.toggle_autoexecute_override(
&conversation_id,
self.terminal_surface_id,
ctx,
);
});
}
}
fn handle_history_event(
&mut self,
_: &BlocklistAIHistoryEvent,
_: &mut warpui::ModelContext<Box<dyn ConversationSelection>>,
) {
}
}
#[cfg(feature = "local_fs")]
#[test]
fn repository_context_reads_github_repo_model() {
App::test((), |mut app| async move {
let context_model = build_test_context_model(&mut app);
let temp_dir = tempfile::TempDir::new().unwrap();
let watcher_handle = app.add_singleton_model(DirectoryWatcher::new_for_testing);
let repository = watcher_handle.update(&mut app, |watcher, ctx| {
watcher
.add_directory(
StandardizedPath::from_local_canonicalized(temp_dir.path()).unwrap(),
ctx,
)
.unwrap()
});
let git_status =
app.add_model(move |ctx| GitRepoStatusModel::new_local_for_test(repository, None, ctx));
let github_repo_model =
app.add_model(move |ctx| GitHubRepoModel::new_local_for_test(git_status, ctx));
github_repo_model.update(&mut app, |model, ctx| {
model.set_repository_info_for_test(
Some(RepositoryInfo {
name: "warp-internal".to_owned(),
owner: Some("warpdotdev".to_owned()),
}),
ctx,
);
});
context_model.update(&mut app, |model, _| {
model.set_github_repo_model(Some(github_repo_model.downgrade()));
});
context_model.read(&app, |model, ctx| {
assert_eq!(
model.repository_context(ctx),
Some(AIAgentContext::Repository {
name: "warp-internal".to_owned(),
owner: Some("warpdotdev".to_owned()),
})
);
});
context_model.update(&mut app, |model, _| {
model.set_github_repo_model(None);
});
context_model.read(&app, |model, ctx| {
assert_eq!(model.repository_context(ctx), None);
});
});
}
/// Builds a [`BlocklistAIContextModel`] with stub dependencies. None of the dependencies are
/// exercised by the methods under test; they only need to satisfy the struct's field types.
fn build_test_context_model(app: &mut App) -> ModelHandle<BlocklistAIContextModel> {
initialize_history_persistence_for_tests(app);
app.add_singleton_model(|_| BlocklistAIHistoryModel::new_for_test());
let terminal_model = Arc::new(FairMutex::new(TerminalModel::new_for_test(
block_size(),
color::List::from(&Colors::default()),
ChannelEventListener::new_for_test(),
Arc::new(Background::default()),
false, /* should_show_bootstrap_block */
None, /* restored_blocks */
false, /* honor_ps1 */
false, /* is_inverted */
None, /* session_startup_path */
)));
let terminal_view_id = EntityId::new();
let conversation_selection = app.add_model(|ctx| {
Box::new(TestConversationSelection::new(terminal_view_id, ctx))
as Box<dyn ConversationSelection>
});
app.add_model(|_| {
BlocklistAIContextModel::new_for_test(
terminal_model,
terminal_view_id,
conversation_selection,
)
})
}
/// Builds context state for a TUI conversation surface.
fn build_tui_context_model(app: &mut App) -> (ModelHandle<BlocklistAIContextModel>, EntityId) {
initialize_history_persistence_for_tests(app);
app.add_singleton_model(|_| BlocklistAIHistoryModel::new_for_test());
let terminal_model = Arc::new(FairMutex::new(TerminalModel::new_for_test(
block_size(),
color::List::from(&Colors::default()),
ChannelEventListener::new_for_test(),
Arc::new(Background::default()),
false,
None,
false,
false,
None,
)));
let terminal_surface_id = EntityId::new();
let conversation_selection = app.add_model(|ctx| {
Box::new(TestConversationSelection::new(terminal_surface_id, ctx))
as Box<dyn ConversationSelection>
});
let model = app.add_model(|_| {
BlocklistAIContextModel::new_for_test(
terminal_model,
terminal_surface_id,
conversation_selection,
)
});
(model, terminal_surface_id)
}
#[test]
fn tui_context_tracks_selected_conversation() {
App::test((), |mut app| async move {
let (model, _) = build_tui_context_model(&mut app);
let conversation_id = AIConversationId::new();
model.update(&mut app, |model, ctx| {
model.set_pending_query_state_for_existing_conversation(
conversation_id,
AgentViewEntryOrigin::Cli,
ctx,
);
});
model.read(&app, |model, ctx| {
assert_eq!(model.selected_conversation_id(ctx), Some(conversation_id));
});
model.update(&mut app, |model, ctx| {
model.set_pending_query_state_for_new_conversation(AgentViewEntryOrigin::Cli, ctx);
});
model.read(&app, |model, ctx| {
assert_eq!(model.selected_conversation_id(ctx), None);
});
});
}
#[test]
fn tui_new_conversation_is_selected_and_terminal_surface_scoped() {
App::test((), |mut app| async move {
let (model, terminal_surface_id) = build_tui_context_model(&mut app);
let history = BlocklistAIHistoryModel::handle(&app);
let conversation_id = model
.update(&mut app, |model, ctx| {
model.try_start_new_conversation(AgentViewEntryOrigin::Cli, ctx)
})
.expect("TUI conversation creation should succeed");
model.read(&app, |model, ctx| {
assert_eq!(model.selected_conversation_id(ctx), Some(conversation_id));
});
history.read(&app, |history, _| {
assert_eq!(
history
.all_live_conversations_for_terminal_surface(terminal_surface_id)
.map(|conversation| conversation.id())
.collect::<Vec<_>>(),
vec![conversation_id]
);
});
});
}
fn make_image_attachment(file_name: &str) -> PendingAttachment {
PendingAttachment::Image(ImageContext {
data: String::new(),
mime_type: "image/png".to_owned(),
file_name: file_name.to_owned(),
is_figma: false,
})
}
fn make_file_attachment(file_name: &str) -> PendingAttachment {
PendingAttachment::File(PendingFile {
file_name: file_name.to_owned(),
file_path: file_name.into(),
mime_type: "text/plain".to_owned(),
})
}
#[test]
fn has_locking_attachment_is_false_for_default_state() {
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.read(&app, |m, _| {
assert!(!m.has_locking_attachment());
});
});
}
#[test]
fn has_locking_attachment_is_false_with_only_pending_block_id() {
// A pending block alone is *not* a locking attachment: only image/file attachments
// should force the input into AI mode (skipping NLD).
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.update(&mut app, |m, _| {
m.insert_pending_block_id_for_test(BlockId::new());
});
model.read(&app, |m, _| assert!(!m.has_locking_attachment()));
});
}
#[test]
fn repository_context_from_repository_info_converts_to_agent_context() {
let repository_info = RepositoryInfo {
name: "warp-internal".to_owned(),
owner: Some("warpdotdev".to_owned()),
};
assert_eq!(
BlocklistAIContextModel::repository_context_from_repository_info(&repository_info),
AIAgentContext::Repository {
name: "warp-internal".to_owned(),
owner: Some("warpdotdev".to_owned()),
}
);
}
#[test]
fn pull_request_context_from_pr_info_excludes_url() {
let pr_info = PrInfo {
number: 123,
url: "https://github.com/warpdotdev/warp/pull/123".to_owned(),
state: "OPEN".to_owned(),
draft: true,
base_branch: "main".to_owned(),
};
assert_eq!(
BlocklistAIContextModel::pull_request_context_from_pr_info(&pr_info),
Some(AIAgentContext::PullRequest {
number: 123,
state: "OPEN".to_owned(),
draft: true,
base_branch: "main".to_owned(),
})
);
}
#[test]
fn pull_request_context_from_pr_info_rejects_numbers_that_do_not_fit_agent_context() {
let pr_info = PrInfo {
number: i32::MAX as u64 + 1,
url: "https://github.com/warpdotdev/warp/pull/2147483648".to_owned(),
state: "OPEN".to_owned(),
draft: false,
base_branch: "main".to_owned(),
};
assert_eq!(
BlocklistAIContextModel::pull_request_context_from_pr_info(&pr_info),
None
);
}
#[cfg(feature = "local_fs")]
#[test]
fn pull_request_context_reads_github_repo_model() {
App::test((), |mut app| async move {
let context_model = build_test_context_model(&mut app);
let temp_dir = tempfile::TempDir::new().unwrap();
let watcher_handle = app.add_singleton_model(DirectoryWatcher::new_for_testing);
let repository = watcher_handle.update(&mut app, |watcher, ctx| {
watcher
.add_directory(
StandardizedPath::from_local_canonicalized(temp_dir.path()).unwrap(),
ctx,
)
.unwrap()
});
let git_status =
app.add_model(move |ctx| GitRepoStatusModel::new_local_for_test(repository, None, ctx));
let github_repo_model =
app.add_model(move |ctx| GitHubRepoModel::new_local_for_test(git_status, ctx));
github_repo_model.update(&mut app, |model, ctx| {
model.set_pr_info_for_test(
Some(PrInfo {
number: 123,
url: "https://github.com/warpdotdev/warp/pull/123".to_owned(),
state: "OPEN".to_owned(),
draft: false,
base_branch: "main".to_owned(),
}),
ctx,
);
});
context_model.update(&mut app, |model, _| {
model.set_github_repo_model(Some(github_repo_model.downgrade()));
});
context_model.read(&app, |model, ctx| {
assert_eq!(
model.pull_request_context(ctx),
Some(AIAgentContext::PullRequest {
number: 123,
state: "OPEN".to_owned(),
draft: false,
base_branch: "main".to_owned(),
})
);
});
context_model.update(&mut app, |model, _| {
model.set_github_repo_model(None);
});
context_model.read(&app, |model, ctx| {
assert_eq!(model.pull_request_context(ctx), None);
});
});
}
#[test]
fn has_locking_attachment_is_false_with_only_pending_selected_text() {
// Selected text alone is *not* a locking attachment: the user could be selecting shell
// command text (e.g. to copy a previously-run command), and forcing the input into AI
// mode in that case would be wrong. Only image or file attachments should force the lock.
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.update(&mut app, |m, _| {
m.set_pending_selected_text_for_test(Some("hello".to_owned()));
});
model.read(&app, |m, _| assert!(!m.has_locking_attachment()));
});
}
#[test]
fn has_locking_attachment_is_true_with_pending_image_attachment() {
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.update(&mut app, |m, _| {
m.append_pending_attachments_for_test(vec![make_image_attachment("a.png")]);
});
model.read(&app, |m, _| assert!(m.has_locking_attachment()));
});
}
#[test]
fn has_locking_attachment_is_true_with_only_file_attachments() {
// File attachments are locking attachments — the user has explicitly attached a file as
// context, which is unambiguously a signal that the next query is intended for the agent.
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.update(&mut app, |m, _| {
m.append_pending_attachments_for_test(vec![
make_file_attachment("notes.txt"),
make_file_attachment("readme.md"),
]);
});
model.read(&app, |m, _| assert!(m.has_locking_attachment()));
});
}
#[test]
fn has_locking_attachment_is_true_with_mixed_image_and_file_attachments() {
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.update(&mut app, |m, _| {
m.append_pending_attachments_for_test(vec![
make_file_attachment("notes.txt"),
make_image_attachment("a.png"),
]);
});
model.read(&app, |m, _| assert!(m.has_locking_attachment()));
});
}
#[test]
fn take_pending_attachments_drains_and_returns_all_staged() {
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
model.update(&mut app, |m, _| {
m.append_pending_attachments_for_test(vec![
make_image_attachment("a.png"),
make_file_attachment("notes.txt"),
]);
});
let taken = model.update(&mut app, |m, ctx| m.take_pending_attachments(ctx));
assert_eq!(taken.len(), 2);
assert_eq!(taken[0].file_name(), "a.png");
assert_eq!(taken[1].file_name(), "notes.txt");
// Draining clears the live staging so the input's attachment chips disappear.
model.read(&app, |m, _| assert!(m.pending_attachments().is_empty()));
});
}
#[test]
fn enqueue_moves_staged_attachments_onto_the_row_and_clears_input() {
// Mirrors the enqueue sites in `input.rs`: `take_pending_attachments` drains the live input
// staging and the drained set is stored on the queued row via `new_with_attachments`, leaving
// no attachments behind in the input.
App::test((), |mut app| async move {
let model = build_test_context_model(&mut app);
let queued = app.add_singleton_model(QueuedQueryModel::new);
let conv = AIConversationId::new();
model.update(&mut app, |m, _| {
m.append_pending_attachments_for_test(vec![
make_image_attachment("a.png"),
make_file_attachment("notes.txt"),
]);
});
// Capture-and-clear, then store on the row (the exact composition used at enqueue time).
let taken = model.update(&mut app, |m, ctx| m.take_pending_attachments(ctx));
let id = queued.update(&mut app, |q, ctx| {
q.append(
conv,
QueuedQuery::new_with_attachments(
"queued".to_owned(),
QueuedQueryOrigin::AutoQueueToggle,
taken,
),
ctx,
)
});
// Live staging is cleared; the row owns the attachments.
model.read(&app, |m, _| assert!(m.pending_attachments().is_empty()));
queued.read(&app, |q, _| {
let attachments = q.attachments_for(conv, id);
assert_eq!(attachments.len(), 2);
assert_eq!(attachments[0].file_name(), "a.png");
assert_eq!(attachments[1].file_name(), "notes.txt");
});
});
}
Reference in New Issue View Git Blame Copy Permalink