tenant.openagents/omega

1#![expect(clippy::result_large_err)]
2use std::iter::zip;
3
4use crate::{
5    debugger_panel::DebugPanel,
6    persistence::SerializedPaneLayout,
7    tests::{init_test, init_test_workspace, start_debug_session},
8};
9use dap::{StoppedEvent, StoppedEventReason, messages::Events};
10use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
11use project::{FakeFs, Project};
12use serde_json::json;
13use util::path;
14use workspace::{Panel, dock::DockPosition};
15
16#[gpui::test]
17async fn test_invert_axis_on_panel_position_change(
18    executor: BackgroundExecutor,
19    cx: &mut TestAppContext,
20) {
21    init_test(cx);
22
23    let fs = FakeFs::new(executor.clone());
24    fs.insert_tree(
25        path!("/project"),
26        json!({
27            "main.rs": "fn main() {\n    println!(\"Hello, world!\");\n}",
28        }),
29    )
30    .await;
31
32    let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
33    let workspace = init_test_workspace(&project, cx).await;
34    let cx = &mut VisualTestContext::from_window(*workspace, cx);
35
36    // Start a debug session
37    let session = start_debug_session(&workspace, cx, |_| {}).unwrap();
38    let client = session.update(cx, |session, _| session.adapter_client().unwrap());
39
40    // Setup thread response
41    client.on_request::<dap::requests::Threads, _>(move |_, _| {
42        Ok(dap::ThreadsResponse { threads: vec![] })
43    });
44
45    cx.run_until_parked();
46
47    client
48        .fake_event(Events::Stopped(StoppedEvent {
49            reason: StoppedEventReason::Pause,
50            description: None,
51            thread_id: Some(1),
52            preserve_focus_hint: None,
53            text: None,
54            all_threads_stopped: None,
55            hit_breakpoint_ids: None,
56        }))
57        .await;
58
59    cx.run_until_parked();
60
61    let (debug_panel, dock_position) = workspace
62        .update(cx, |workspace, window, cx| {
63            let debug_panel = workspace.panel::<DebugPanel>(cx).unwrap();
64            let dock_position = debug_panel.read(cx).position(window, cx);
65            (debug_panel, dock_position)
66        })
67        .unwrap();
68
69    assert_eq!(
70        dock_position,
71        DockPosition::Bottom,
72        "Default dock position should be bottom for debug panel"
73    );
74
75    let pre_serialized_layout = debug_panel
76        .read_with(cx, |panel, cx| {
77            panel
78                .active_session()
79                .unwrap()
80                .read(cx)
81                .running_state()
82                .read(cx)
83                .serialized_layout(cx)
84        })
85        .panes;
86
87    let post_serialized_layout = debug_panel
88        .update_in(cx, |panel, window, cx| {
89            panel.set_position(DockPosition::Right, window, cx);
90
91            panel
92                .active_session()
93                .unwrap()
94                .read(cx)
95                .running_state()
96                .read(cx)
97                .serialized_layout(cx)
98        })
99        .panes;
100
101    let pre_panes = pre_serialized_layout.in_order();
102    let post_panes = post_serialized_layout.in_order();
103
104    assert_eq!(pre_panes.len(), post_panes.len());
105
106    for (pre, post) in zip(pre_panes, post_panes) {
107        match (pre, post) {
108            (
109                SerializedPaneLayout::Group {
110                    axis: pre_axis,
111                    flexes: pre_flexes,
112                    children: _,
113                },
114                SerializedPaneLayout::Group {
115                    axis: post_axis,
116                    flexes: post_flexes,
117                    children: _,
118                },
119            ) => {
120                assert_ne!(pre_axis, post_axis);
121                assert_eq!(pre_flexes, post_flexes);
122            }
123            (SerializedPaneLayout::Pane(pre_pane), SerializedPaneLayout::Pane(post_pane)) => {
124                assert_eq!(pre_pane.children, post_pane.children);
125                assert_eq!(pre_pane.active_item, post_pane.active_item);
126            }
127            _ => {
128                panic!("Variants don't match")
129            }
130        }
131    }
132}
133