1use std::sync::Arc;
  2
  3use anyhow::{Context as _, Result};
  4use dap::adapters::DebugTaskDefinition;
  5use dap::client::DebugAdapterClient;
  6use gpui::{Entity, TestAppContext, WindowHandle};
  7use project::{Project, debugger::session::Session};
  8use settings::SettingsStore;
  9use task::SharedTaskContext;
 10use terminal_view::terminal_panel::TerminalPanel;
 11use workspace::MultiWorkspace;
 12use workspace::dock::Panel;
 13
 14use crate::{debugger_panel::DebugPanel, session::DebugSession};
 15
 16#[cfg(test)]
 17mod attach_modal;
 18#[cfg(test)]
 19mod console;
 20#[cfg(test)]
 21mod dap_logger;
 22#[cfg(test)]
 23mod debugger_panel;
 24#[cfg(test)]
 25mod inline_values;
 26#[cfg(test)]
 27mod module_list;
 28#[cfg(test)]
 29mod new_process_modal;
 30#[cfg(test)]
 31mod persistence;
 32#[cfg(test)]
 33mod stack_frame_list;
 34#[cfg(test)]
 35mod variable_list;
 36
 37pub fn init_test(cx: &mut gpui::TestAppContext) {
 38    #[cfg(test)]
 39    zlog::init_test();
 40
 41    cx.update(|cx| {
 42        let settings = SettingsStore::test(cx);
 43        cx.set_global(settings);
 44        terminal_view::init(cx);
 45        theme::init(theme::LoadThemes::JustBase, cx);
 46        command_palette_hooks::init(cx);
 47        editor::init(cx);
 48        crate::init(cx);
 49        dap_adapters::init(cx);
 50    });
 51}
 52
 53pub async fn init_test_workspace(
 54    project: &Entity<Project>,
 55    cx: &mut TestAppContext,
 56) -> WindowHandle<MultiWorkspace> {
 57    let workspace_handle =
 58        cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
 59
 60    let debugger_panel = workspace_handle
 61        .update(cx, |multi, window, cx| {
 62            multi.workspace().update(cx, |_workspace, cx| {
 63                cx.spawn_in(window, async move |this, cx| {
 64                    DebugPanel::load(this, cx).await
 65                })
 66            })
 67        })
 68        .unwrap()
 69        .await
 70        .expect("Failed to load debug panel");
 71
 72    let terminal_panel = workspace_handle
 73        .update(cx, |multi, window, cx| {
 74            let weak_workspace = multi.workspace().downgrade();
 75            cx.spawn_in(window, async move |_, cx| {
 76                TerminalPanel::load(weak_workspace, cx.clone()).await
 77            })
 78        })
 79        .unwrap()
 80        .await
 81        .expect("Failed to load terminal panel");
 82
 83    workspace_handle
 84        .update(cx, |multi, window, cx| {
 85            multi.workspace().update(cx, |workspace, cx| {
 86                let position = debugger_panel.read(cx).position(window, cx);
 87                workspace.add_panel(debugger_panel, position, window, cx);
 88                let position = terminal_panel.read(cx).position(window, cx);
 89                workspace.add_panel(terminal_panel, position, window, cx);
 90            });
 91        })
 92        .unwrap();
 93    workspace_handle
 94}
 95
 96#[track_caller]
 97pub fn active_debug_session_panel(
 98    workspace: WindowHandle<MultiWorkspace>,
 99    cx: &mut TestAppContext,
100) -> Entity<DebugSession> {
101    workspace
102        .update(cx, |multi, _window, cx| {
103            multi.workspace().update(cx, |workspace, cx| {
104                let debug_panel = workspace.panel::<DebugPanel>(cx).unwrap();
105                debug_panel
106                    .update(cx, |this, _| this.active_session())
107                    .unwrap()
108            })
109        })
110        .unwrap()
111}
112
113pub fn start_debug_session_with<T: Fn(&Arc<DebugAdapterClient>) + 'static>(
114    workspace: &WindowHandle<MultiWorkspace>,
115    cx: &mut gpui::TestAppContext,
116    config: DebugTaskDefinition,
117    configure: T,
118) -> Result<Entity<Session>> {
119    let _subscription = project::debugger::test::intercept_debug_sessions(cx, configure);
120    workspace.update(cx, |multi, window, cx| {
121        multi.workspace().update(cx, |workspace, cx| {
122            workspace.start_debug_session(
123                config.to_scenario(),
124                SharedTaskContext::default(),
125                None,
126                None,
127                window,
128                cx,
129            )
130        })
131    })?;
132    cx.run_until_parked();
133    let session = workspace.read_with(cx, |workspace, cx| {
134        workspace
135            .workspace()
136            .read(cx)
137            .panel::<DebugPanel>(cx)
138            .and_then(|panel| panel.read(cx).active_session())
139            .map(|session| session.read(cx).running_state().read(cx).session())
140            .cloned()
141            .context("Failed to get active session")
142    })??;
143
144    Ok(session)
145}
146
147pub fn start_debug_session<T: Fn(&Arc<DebugAdapterClient>) + 'static>(
148    workspace: &WindowHandle<MultiWorkspace>,
149    cx: &mut gpui::TestAppContext,
150    configure: T,
151) -> Result<Entity<Session>> {
152    use serde_json::json;
153
154    start_debug_session_with(
155        workspace,
156        cx,
157        DebugTaskDefinition {
158            adapter: "fake-adapter".into(),
159            label: "test".into(),
160            config: json!({
161                "request": "launch"
162            }),
163            tcp_connection: None,
164        },
165        configure,
166    )
167}