Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b

app/src/integration_testing/codebase_context/mod.rs

@@ -0,0 +1,3 @@
+pub mod step;
+
+pub use step::*;

app/src/integration_testing/codebase_context/step.rs

@@ -0,0 +1,91 @@
+use std::{path::PathBuf, time::Duration};
+
+use ai::index::full_source_code_embedding::manager::CodebaseIndexManager;
+use settings::Setting;
+use warpui::{
+    async_assert,
+    integration::{AssertionOutcome, StepData, TestStep},
+    App, ReadModel, SingletonEntity, UpdateModel, WindowId,
+};
+
+use crate::{
+    integration_testing::step::new_step_with_default_assertions, settings::CodeSettings,
+    workspace::ActiveSession,
+};
+
+const SYNC_DEFAULT_TIMEOUT: Duration = Duration::from_secs(15 * 60);
+const CWD_DATA_KEY: &str = "cwd";
+
+fn active_session_cwd(app: &App, window_id: WindowId) -> Option<PathBuf> {
+    app.read_model(&ActiveSession::handle(app), |active_session, _ctx| {
+        active_session
+            .path_if_local(window_id)
+            .map(|path| path.to_path_buf())
+    })
+}
+
+/// Attempts to sync the git repo at the current working directory of the active
+/// session.
+///
+/// Assumes that the active session is in a git repo. If not, the step will
+/// pass.
+pub fn sync_current_codebase_index() -> TestStep {
+    new_step_with_default_assertions("Sync current codebase index")
+        .set_timeout(SYNC_DEFAULT_TIMEOUT)
+        .add_assertion(move |app, _window_id| {
+            app.read_model(&CodeSettings::handle(app), |code_settings, _ctx| {
+                async_assert!(
+                    *code_settings.codebase_context_enabled.value(),
+                    "Codebase context should be enabled"
+                )
+            })
+        })
+        .add_assertion(move |app, window_id| {
+            let Some(cwd) = active_session_cwd(app, window_id) else {
+                return AssertionOutcome::failure(
+                    "Expected active session to have a cwd".to_string(),
+                );
+            };
+            let Ok(canonicalized_path) = dunce::canonicalize(&cwd) else {
+                return AssertionOutcome::failure(format!(
+                    "Failed to canonicalize repo path: {}",
+                    cwd.display()
+                ));
+            };
+
+            // Kick off codebase indexing at the current directory.
+            app.update_model(&CodebaseIndexManager::handle(app), |manager, ctx| {
+                manager.index_directory(canonicalized_path.clone(), ctx);
+            });
+
+            AssertionOutcome::SuccessWithData(StepData::new(
+                CWD_DATA_KEY.to_string(),
+                canonicalized_path,
+            ))
+        })
+        .add_named_assertion_with_data_from_prior_step(
+            "Assert that codebase index has been synced",
+            |app, _window_id, step_data_map| {
+                let cwd = step_data_map
+                    .get::<String, PathBuf>(CWD_DATA_KEY.into())
+                    .expect("No cwd");
+
+                let status = app.read_model(&CodebaseIndexManager::handle(app), |manager, ctx| {
+                    manager.get_codebase_index_status_for_path(cwd, ctx)
+                });
+                match status {
+                    Some(status) => {
+                        async_assert!(
+                            status.has_synced_version()
+                                && status.last_sync_successful().unwrap_or(false),
+                            "Codebase index for {} should be synced and successful",
+                            cwd.display()
+                        )
+                    }
+                    // If the index hasn't been created, then we are not in a git repo.
+                    // Mark as success to avoid failing evals that are not in git repos.
+                    None => AssertionOutcome::Success,
+                }
+            },
+        )
+}