From b4945eff81d3c55a396304e95b1ff1a863ef8eb2 Mon Sep 17 00:00:00 2001 From: Crizant Lai Date: Tue, 3 Nov 2026 13:00:37 +1000 Subject: [PATCH 1/4] fix(desktop): preserve editor state across tab switches - Retain editor sessions and per-request scroll positions across tab changes --- CHANGELOG.md | 6 + crates/desktop/src/app/chrome/environments.rs | 2 +- crates/desktop/src/app/documentation.rs | 2 +- crates/desktop/src/app/mod.rs | 9 +- .../desktop/src/app/render/documentation.rs | 16 +- .../desktop/src/app/render/request_editor.rs | 21 +- .../src/app/render/request_editor/body.rs | 11 +- .../src/app/render/request_editor/graphql.rs | 3 + .../app/render/request_editor/websocket.rs | 1 + crates/desktop/src/app/render/response.rs | 23 +- crates/desktop/src/app/render/websocket.rs | 1 + crates/desktop/src/app/tabs.rs | 14 +- crates/desktop/src/app/tests.rs | 1 + crates/desktop/src/app/tests/editor_state.rs | 291 ++++++++++++++++++ crates/desktop/src/app/tests/response.rs | 80 ++++- crates/desktop/src/app/tests/workspace.rs | 79 ++++- crates/desktop/src/app/workspace.rs | 18 +- .../src/components/components_tests.rs | 3 + crates/desktop/src/components/editor.rs | 2 +- crates/desktop/src/components/editor/core.rs | 177 ++++++++--- .../src/components/editor/native_tests.rs | 1 + .../desktop/src/components/editor/response.rs | 15 + crates/desktop/src/components/mod.rs | 2 + crates/desktop/src/request_editor.rs | 40 ++- crates/desktop/src/response_viewer/mod.rs | 47 +++ crates/desktop/src/response_viewer/tests.rs | 58 ++++ 26 files changed, 819 insertions(+), 104 deletions(-) create mode 100644 crates/desktop/src/app/tests/editor_state.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index b4cc6f99..1e5761cd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,12 @@ Release dates use Australia/Brisbane time (UTC+10). ## [Unreleased] +### Fixed + +- Preserve editor scroll positions, selections, undo history, and search sessions when + switching request, response, or documentation tabs. Keep request-section and response + Inspect list scroll positions separate for each request. + ## [2.4.0] - 2026-10-29 ### Added diff --git a/crates/desktop/src/app/chrome/environments.rs b/crates/desktop/src/app/chrome/environments.rs index 7400550a..37810f52 100644 --- a/crates/desktop/src/app/chrome/environments.rs +++ b/crates/desktop/src/app/chrome/environments.rs @@ -980,7 +980,7 @@ impl ProbeApp { crate::app::documentation::documentation_text( dialog.draft().description.as_ref(), ), - description_id, + (description_id, None), "environment-manager-description", false, move |value, _, cx| { diff --git a/crates/desktop/src/app/documentation.rs b/crates/desktop/src/app/documentation.rs index 07777a8f..24bdca7a 100644 --- a/crates/desktop/src/app/documentation.rs +++ b/crates/desktop/src/app/documentation.rs @@ -182,7 +182,7 @@ impl ProbeApp { if self.pending_overview_targets(&pending).is_empty() && self.documentation_save_task.is_none() { - self.shell.close_overview(tab); + self.remove_open_tab(crate::shell::OpenTab::Overview(tab)); self.select_and_reveal_active_request_in_sidebar(); self.reveal_active_tab(); self.persist_session(cx); diff --git a/crates/desktop/src/app/mod.rs b/crates/desktop/src/app/mod.rs index d09a369c..e6338a80 100644 --- a/crates/desktop/src/app/mod.rs +++ b/crates/desktop/src/app/mod.rs @@ -292,6 +292,8 @@ pub(crate) struct ProbeApp { request_save_task: Option>, documentation_save_task: Option>, overview_drafts: BTreeMap, + overview_editors: + std::cell::RefCell>, pending_documentation_saves: std::collections::VecDeque, environment_save_task: Option>, environment_save_workspace_path: Option, @@ -337,12 +339,9 @@ pub(crate) struct ProbeApp { destination_scroll: ScrollHandle, revealed_destination: Option, tree_scroll: UniformListScrollHandle, - inspector_scroll: UniformListScrollHandle, environment_variables_scroll: UniformListScrollHandle, - request_section_scroll: ScrollHandle, request_list_scroll: components::ListScroll, environment_list_scroll: components::ListScroll, - request_section_scroll_owner: Cell>, send_and_save_generation: u64, send_and_save_targets: BTreeMap, inspector_list_width: f32, @@ -463,6 +462,7 @@ impl ProbeApp { request_save_task: None, documentation_save_task: None, overview_drafts: BTreeMap::new(), + overview_editors: Default::default(), pending_documentation_saves: std::collections::VecDeque::new(), environment_save_task: None, environment_save_workspace_path: None, @@ -505,12 +505,9 @@ impl ProbeApp { destination_scroll: ScrollHandle::new(), revealed_destination: None, tree_scroll: UniformListScrollHandle::new(), - inspector_scroll: UniformListScrollHandle::new(), environment_variables_scroll: UniformListScrollHandle::new(), - request_section_scroll: ScrollHandle::new(), request_list_scroll: cx.new(|_| components::ListScrollState::default()), environment_list_scroll: cx.new(|_| components::ListScrollState::default()), - request_section_scroll_owner: Cell::new(None), send_and_save_generation: 0, send_and_save_targets: BTreeMap::new(), inspector_list_width: DEFAULT_INSPECT_LIST_WIDTH, diff --git a/crates/desktop/src/app/render/documentation.rs b/crates/desktop/src/app/render/documentation.rs index 3f91849d..5128072f 100644 --- a/crates/desktop/src/app/render/documentation.rs +++ b/crates/desktop/src/app/render/documentation.rs @@ -6,6 +6,7 @@ pub(super) fn documentation_sections( first_label: &'static str, values: [Option<&str>; 2], ids: [gpui_kit::ElementId; 2], + editors: [components::RetainedEditorState; 2], on_change: impl Fn(bool, gpui_kit::SharedString, &mut Window, &mut gpui_kit::App) + 'static, ) -> gpui_kit::Div { let on_change = Rc::new(on_change); @@ -15,10 +16,10 @@ pub(super) fn documentation_sections( .flex() .flex_col() .gap(px(theme.metrics.spacing_2)); - for (index, ((label, text), id)) in [first_label, "Documentation"] + for (index, ((label, text), (id, editor))) in [first_label, "Documentation"] .into_iter() .zip(values) - .zip(ids) + .zip(ids.into_iter().zip(editors)) .enumerate() { let on_change = on_change.clone(); @@ -27,7 +28,7 @@ pub(super) fn documentation_sections( theme, label, text, - id, + (id, Some(editor)), if grow { "documentation-docs-editor" } else { @@ -47,11 +48,12 @@ pub(in crate::app) fn documentation_text_field( theme: Theme, label: &'static str, text: Option<&str>, - id: gpui_kit::ElementId, + editor: (gpui_kit::ElementId, Option), container_id: &'static str, grow: bool, on_change: impl Fn(gpui_kit::SharedString, &mut Window, &mut gpui_kit::App) + 'static, ) -> gpui_kit::Div { + let (id, editor) = editor; div() .min_h(px(0.0)) .when(!grow, |section| section.flex_none()) @@ -77,6 +79,7 @@ pub(in crate::app) fn documentation_text_field( .w_full() .child(components::documentation_text_input( theme, + editor, id, text.unwrap_or_default().to_owned(), label, @@ -181,6 +184,11 @@ impl ProbeApp { documentation_text(content.docs.as_ref()), ], ids, + self.overview_editors + .borrow_mut() + .entry(target.clone()) + .or_default() + .clone(), move |docs, value, _, cx| { let _ = edit_view.update(cx, |view, cx| { view.edit_overview(edit_target.clone(), docs, value.to_string(), cx) diff --git a/crates/desktop/src/app/render/request_editor.rs b/crates/desktop/src/app/render/request_editor.rs index 5fb1eaa9..71bfd88c 100644 --- a/crates/desktop/src/app/render/request_editor.rs +++ b/crates/desktop/src/app/render/request_editor.rs @@ -209,21 +209,12 @@ impl ProbeApp { section_kind, EditorSection::Body | EditorSection::Docs | EditorSection::WebSocketMessage ) && !section_kind.is_graphql(); - if section_scrolls && self.request_section_scroll_owner.get() != Some((key, section_kind)) { - self.request_section_scroll - .set_offset(point(px(0.0), px(0.0))); - self.request_section_scroll_owner - .set(Some((key, section_kind))); - } + let section_scroll = self.request_editor.scroll(key, section_kind); let list_scroll = section_scrolls.then_some(&self.request_list_scroll); let section = self.render_request_section(key, &request, theme, list_scroll, cx); let section = if section_scrolls { - components::list_scroll_region( - section, - &self.request_section_scroll, - &self.request_list_scroll, - ) - .into_any_element() + components::list_scroll_region(section, §ion_scroll, &self.request_list_scroll) + .into_any_element() } else { section }; @@ -469,7 +460,7 @@ impl ProbeApp { .when(section_scrolls, |content| { content .overflow_y_scroll() - .track_scroll(&self.request_section_scroll) + .track_scroll(§ion_scroll) }) .child(section), ) @@ -500,6 +491,10 @@ impl ProbeApp { ("request-description", key.slot()).into(), ("request-docs", key.slot()).into(), ], + [ + self.request_editor.editor(key, "request-description"), + self.request_editor.editor(key, "request-docs"), + ], move |docs, value, _, cx| { let _ = view.update(cx, |view, cx| { view.edit_request( diff --git a/crates/desktop/src/app/render/request_editor/body.rs b/crates/desktop/src/app/render/request_editor/body.rs index 3c2d5377..45eac30e 100644 --- a/crates/desktop/src/app/render/request_editor/body.rs +++ b/crates/desktop/src/app/render/request_editor/body.rs @@ -56,7 +56,16 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, - ("request-body", key.slot()), + self.request_editor.editor( + key, + match raw.kind { + RawBodyKind::Json => "body-json", + RawBodyKind::Xml => "body-xml", + RawBodyKind::Sparql => "body-sparql", + _ => "body-text", + }, + ), + format!("request-body-{}-{:?}", key.slot(), raw.kind), raw.data.clone(), match raw.kind { RawBodyKind::Json => components::BodySyntax::Json, diff --git a/crates/desktop/src/app/render/request_editor/graphql.rs b/crates/desktop/src/app/render/request_editor/graphql.rs index 0789ee87..113d4554 100644 --- a/crates/desktop/src/app/render/request_editor/graphql.rs +++ b/crates/desktop/src/app/render/request_editor/graphql.rs @@ -27,6 +27,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "graphql-query"), ("graphql-query", key.slot()), query.to_owned(), components::BodySyntax::Plain, @@ -74,6 +75,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "graphql-variables"), ("graphql-variables", key.slot()), variables, components::BodySyntax::Json, @@ -177,6 +179,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "graphql-extensions"), ("graphql-extensions", key.slot()), extensions, components::BodySyntax::Json, diff --git a/crates/desktop/src/app/render/request_editor/websocket.rs b/crates/desktop/src/app/render/request_editor/websocket.rs index 6f156e4c..f60fa7ea 100644 --- a/crates/desktop/src/app/render/request_editor/websocket.rs +++ b/crates/desktop/src/app/render/request_editor/websocket.rs @@ -105,6 +105,7 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::body_text_input( theme, + self.request_editor.editor(key, "websocket-message"), ("websocket-message", key.slot()), message.data.clone(), match kind { diff --git a/crates/desktop/src/app/render/response.rs b/crates/desktop/src/app/render/response.rs index 62050fbc..da7dfaf4 100644 --- a/crates/desktop/src/app/render/response.rs +++ b/crates/desktop/src/app/render/response.rs @@ -896,7 +896,7 @@ impl ProbeApp { let list = match self.response_viewer.tab(key) { ResponseViewerTab::Assertions => self.render_assertion_results(key, theme, cx), - ResponseViewerTab::Headers => self.render_response_headers(theme, document, cx), + ResponseViewerTab::Headers => self.render_response_headers(theme, key, document, cx), ResponseViewerTab::Inspect => self.render_response_inspector(theme, key, document, cx), ResponseViewerTab::Pretty if document.is_image() => { self.render_response_image(theme, key, document) @@ -1076,7 +1076,14 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::response_body_input( theme, - "response-body-editor", + self.response_viewer + .editor(key, self.response_viewer.tab(key)), + format!( + "response-body-editor-{}-{:?}-{:?}", + document.generation, + self.response_viewer.tab(key), + self.response_viewer.raw_view(key) + ), text, components::ResponseBodyInputOptions::new( if self.response_viewer.tab(key) == ResponseViewerTab::Pretty { @@ -1160,6 +1167,7 @@ impl ProbeApp { pub(super) fn render_response_headers( &self, theme: Theme, + key: probe_core::RequestKey, document: &PreparedDocument, cx: &mut Context, ) -> gpui_kit::AnyElement { @@ -1174,7 +1182,8 @@ impl ProbeApp { .min_h(px(0.0)) .child(components::response_headers_input( theme, - "response-headers-editor", + self.response_viewer.editor(key, ResponseViewerTab::Headers), + format!("response-headers-editor-{}", document.generation), &document.headers, move |range, cx| { #[cfg(test)] @@ -1203,7 +1212,8 @@ impl ProbeApp { if let Some(selection) = self.pending_inspector_reveal.take() && let Some(index) = inspect_row_index(&rows, selection) { - self.inspector_scroll + self.response_viewer + .inspector_scroll(key) .scroll_to_item(index, ScrollStrategy::Nearest); } let selected = self.response_viewer.inspection_selection(key); @@ -1234,7 +1244,7 @@ impl ProbeApp { }) }) .size_full() - .track_scroll(&self.inspector_scroll); + .track_scroll(self.response_viewer.inspector_scroll(key)); if row_count == 0 && !document.inspection_pending { return Self::inspect_tab_content_boundary( @@ -1299,7 +1309,8 @@ impl ProbeApp { .size_full() .child(components::response_inspector_input( theme, - "response-inspector-editor", + self.response_viewer.editor(key, ResponseViewerTab::Inspect), + format!("response-inspector-editor-{}", document.generation), detail, move |range, cx| { #[cfg(test)] diff --git a/crates/desktop/src/app/render/websocket.rs b/crates/desktop/src/app/render/websocket.rs index e8879793..ec5a7d1d 100644 --- a/crates/desktop/src/app/render/websocket.rs +++ b/crates/desktop/src/app/render/websocket.rs @@ -279,6 +279,7 @@ impl ProbeApp { .flex_col() .child(components::websocket_composer( theme, + self.request_editor.editor(key, "websocket-composer"), ("websocket-draft", key.slot()).into(), state.map(|s| s.draft.clone()).unwrap_or_default(), connected, diff --git a/crates/desktop/src/app/tabs.rs b/crates/desktop/src/app/tabs.rs index ec4ec7fe..394b1c85 100644 --- a/crates/desktop/src/app/tabs.rs +++ b/crates/desktop/src/app/tabs.rs @@ -219,8 +219,16 @@ impl ProbeApp { cx.notify(); } - fn remove_open_tab(&mut self, tab: crate::shell::OpenTab) { - self.shell.close(tab); + pub(super) fn remove_open_tab(&mut self, tab: crate::shell::OpenTab) { + if let crate::shell::OpenTab::Overview(overview) = tab + && let Some(target) = self.overview_target(overview) + { + self.overview_editors.get_mut().remove(&target); + } + match tab { + crate::shell::OpenTab::Overview(overview) => self.shell.close_overview(overview), + crate::shell::OpenTab::Request(_) => self.shell.close(tab), + } let crate::shell::OpenTab::Request(key) = tab else { return; }; @@ -754,7 +762,7 @@ impl ProbeApp { .map(crate::shell::OverviewTab::Folder), }; if let Some(tab) = tab { - self.shell.close_overview(tab); + self.remove_open_tab(crate::shell::OpenTab::Overview(tab)); } self.select_and_reveal_active_request_in_sidebar(); self.reveal_active_tab(); diff --git a/crates/desktop/src/app/tests.rs b/crates/desktop/src/app/tests.rs index 69968e69..84e66e8e 100644 --- a/crates/desktop/src/app/tests.rs +++ b/crates/desktop/src/app/tests.rs @@ -1400,6 +1400,7 @@ fn writable_structure_fixture(suffix: &str) -> PathBuf { mod assertions; mod curl_import; +mod editor_state; mod environments; mod graphql; mod interactions; diff --git a/crates/desktop/src/app/tests/editor_state.rs b/crates/desktop/src/app/tests/editor_state.rs new file mode 100644 index 00000000..693caf45 --- /dev/null +++ b/crates/desktop/src/app/tests/editor_state.rs @@ -0,0 +1,291 @@ +use super::*; +use gpui_kit::base::input::EditorState; +use probe_core::{ + Body, GraphqlBody, GraphqlOperation, RawBody, RawBodyKind, RequestBody, RequestKind, +}; + +#[gpui_kit::test] +fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppContext) { + cx.update(Theme::init); + cx.update(bind_platform_hotkeys); + let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); + let fixture = bundled_fixture(); + let mut workspace = probe_opencollection::load_workspace(&fixture).unwrap(); + let http = workspace.requests()[0].key(); + let text = "needle row\n".repeat(100); + let request = workspace.request_mut(http).unwrap(); + request.kind = RequestKind::Http { + body: Some(RequestBody::Single(Body::Raw(RawBody { + kind: RawBodyKind::Text, + data: text.clone(), + }))), + }; + request.docs = Some(text.clone()); + let object = serde_json::from_value(serde_json::json!({"rows": vec!["needle"; 100]})).unwrap(); + let graphql = workspace.add_detached_request(Request { + kind: RequestKind::Graphql { + body: Some(GraphqlBody::Single(GraphqlOperation { + query: Some(text.clone()), + variables: Some(object), + extensions: Some( + serde_json::from_value(serde_json::json!({"rows": vec!["needle"; 100]})) + .unwrap(), + ), + ..Default::default() + })), + }, + ..Default::default() + }); + let websocket = workspace.add_detached_request(Request { + kind: RequestKind::WebSocket { + message: Some(probe_core::WebSocketMessageSet::Single( + probe_core::WebSocketMessage { + kind: probe_core::WebSocketMessageKind::Text, + data: text.clone(), + }, + )), + }, + ..Default::default() + }); + window + .update(cx, |view, _, cx| { + view.session_store = None; + view.set_workspace(fixture, workspace); + let (cancel, _) = oneshot::channel(); + view.websocket.begin(websocket, cancel); + let session = view.websocket.sessions.get_mut(&websocket).unwrap(); + session.state = crate::websocket::ConnectionState::Connected; + session.draft = text; + view.select_request(http, cx); + }) + .unwrap(); + cx.run_until_parked(); + + for (key, section, slot) in [ + (http, EditorSection::Body, "body-text"), + (http, EditorSection::Docs, "request-docs"), + (graphql, EditorSection::GraphqlQuery, "graphql-query"), + ( + graphql, + EditorSection::GraphqlVariables, + "graphql-variables", + ), + ( + graphql, + EditorSection::GraphqlExtensions, + "graphql-extensions", + ), + ( + websocket, + EditorSection::WebSocketMessage, + "websocket-message", + ), + ( + websocket, + EditorSection::WebSocketMessage, + "websocket-composer", + ), + ] { + window + .update(cx, |view, _, cx| { + view.select_request(key, cx); + view.request_editor.set_section(key, section); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + let editor = window + .update(cx, |view, window, cx| { + let editor = view.request_editor.editor(key, slot).editor(cx); + editor.update(cx, |editor, cx| { + editor.set_selected_range(0..0, cx); + editor.focus(window, cx); + }); + editor + }) + .unwrap(); + cx.simulate_keystrokes(window.into(), find_shortcut()); + cx.simulate_input(window.into(), "needle"); + cx.run_until_parked(); + editor.update(cx, |editor: &mut EditorState, cx| { + editor.next_search_match(cx); + }); + cx.run_until_parked(); + editor.update(cx, |editor, cx| { + editor.set_scroll_offset(point(px(0.0), px(-100.0)), cx) + }); + cx.run_until_parked(); + let before = editor.read_with(cx, |editor, _| { + ( + editor.scroll_offset(), + editor.selected_range(), + editor.search_session().matcher.current_match_index(), + ) + }); + assert!(before.0.y < px(0.0), "{slot} should be scrolled"); + // Both section switches and request switches unmount the editor. + for other in [false, true] { + window + .update(cx, |view, _, cx| { + if other { + view.select_request(if key == http { graphql } else { http }, cx); + } else { + view.request_editor.set_section(key, EditorSection::Headers); + cx.notify(); + } + }) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.select_request(key, cx); + view.request_editor.set_section(key, section); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + assert_eq!(view.request_editor.editor(key, slot).editor(cx), editor); + let state = editor.read(cx); + assert_eq!(state.scroll_offset(), before.0, "{slot}"); + assert_eq!(state.selected_range(), before.1, "{slot}"); + assert_eq!(state.search_session().query, "needle", "{slot}"); + assert_eq!( + state.search_session().matcher.current_match_index(), + before.2, + "{slot}" + ); + }) + .unwrap(); + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!( + visual.debug_bounds("editor-search-card").is_some(), + "{slot}" + ); + } + // Close this search so another editor in the same request can be checked independently. + window + .update(cx, |_, window, cx| { + editor.update(cx, |editor, cx| editor.focus(window, cx)) + }) + .unwrap(); + cx.simulate_keystrokes(window.into(), "escape"); + cx.run_until_parked(); + } + // Incomplete JSON is a local draft; the last valid model value must not replace it. + window + .update(cx, |view, _, cx| { + view.select_request(graphql, cx); + view.request_editor + .set_section(graphql, EditorSection::GraphqlVariables); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + let variables = window + .update(cx, |view, window, cx| { + let editor = view + .request_editor + .editor(graphql, "graphql-variables") + .editor(cx); + editor.update(cx, |editor, cx| { + editor.set_selected_range(0..editor.value().len(), cx); + editor.focus(window, cx); + }); + editor + }) + .unwrap(); + cx.simulate_input(window.into(), "{"); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| view.select_request(http, cx)) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| view.select_request(graphql, cx)) + .unwrap(); + cx.run_until_parked(); + assert_eq!(variables.read_with(cx, |editor, _| editor.value()), "{"); + let weak = variables.downgrade(); + drop(variables); + window + .update(cx, |view, _, cx| { + view.remove_open_tab(crate::shell::OpenTab::Request(graphql)); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + assert!( + weak.upgrade().is_none(), + "closing the tab releases its native editor" + ); +} + +#[gpui_kit::test] +fn overview_editor_keeps_undo_and_search_until_closed(cx: &mut TestAppContext) { + cx.update(Theme::init); + cx.update(bind_platform_hotkeys); + let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); + let fixture = bundled_fixture(); + let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); + let request = workspace.requests()[0].key(); + let overview = crate::shell::OverviewTab::Collection; + window + .update(cx, |view, _, cx| { + view.session_store = None; + view.set_workspace(fixture, workspace); + view.select_open_tab(crate::shell::OpenTab::Overview(overview), cx); + }) + .unwrap(); + cx.run_until_parked(); + let target = super::super::documentation::OverviewTarget::Collection; + let editor = window + .update(cx, |view, window, cx| { + let editor = view.overview_editors.borrow()[&target][1].editor(cx); + editor.update(cx, |editor, cx| editor.focus(window, cx)); + editor + }) + .unwrap(); + let original = editor.read_with(cx, |editor, _| editor.value()); + cx.simulate_input(window.into(), "additional documentation"); + cx.run_until_parked(); + cx.simulate_keystrokes(window.into(), find_shortcut()); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| view.select_request(request, cx)) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.select_open_tab(crate::shell::OpenTab::Overview(overview), cx) + }) + .unwrap(); + cx.run_until_parked(); + { + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_some()); + } + window + .update(cx, |_, window, cx| { + editor.update(cx, |editor, cx| editor.focus(window, cx)) + }) + .unwrap(); + cx.simulate_keystrokes(window.into(), "escape"); + cx.simulate_keystrokes( + window.into(), + if cfg!(target_os = "macos") { + "cmd-z" + } else { + "ctrl-z" + }, + ); + cx.run_until_parked(); + assert_eq!(editor.read_with(cx, |editor, _| editor.value()), original); + window + .update(cx, |view, _, _| { + view.remove_open_tab(crate::shell::OpenTab::Overview(overview)); + assert!(!view.overview_editors.borrow().contains_key(&target)); + }) + .unwrap(); +} diff --git a/crates/desktop/src/app/tests/response.rs b/crates/desktop/src/app/tests/response.rs index d2d3d1bc..3877a40c 100644 --- a/crates/desktop/src/app/tests/response.rs +++ b/crates/desktop/src/app/tests/response.rs @@ -361,6 +361,7 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont .expect("fixture should exist"); let workspace = probe_opencollection::load_workspace(&fixture).expect("fixture should load"); let request_key = workspace.requests()[0].key(); + let other_request = workspace.requests()[1].key(); window .update(cx, |view, _, cx| { view.session_store = None; @@ -368,7 +369,11 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont view.select_request(request_key, cx); let (cancellation, _) = tokio::sync::oneshot::channel(); let generation = view.execution.begin(request_key, cancellation); - let body = br#"{"createdAt":1787482800,"ok":true}"#.to_vec(); + let body = format!( + r#"{{"createdAt":1787482800,"ok":true,"rows":{:?}}}"#, + (0..200).collect::>() + ) + .into_bytes(); view.complete_execution( request_key, generation, @@ -482,6 +487,79 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont assert!(visual.debug_bounds("editor-search-card").is_some()); assert!(visual.debug_bounds("response-body").is_some()); } + let editor = window + .update(cx, |view, _, cx| { + let editor = view + .response_viewer + .editor(request_key, ResponseViewerTab::Pretty) + .editor(cx); + editor.update(cx, |editor, cx| { + editor.set_scroll_offset(gpui_kit::point(px(0.0), px(-400.0)), cx) + }); + editor + }) + .unwrap(); + cx.run_until_parked(); + let offset = editor.read_with(cx, |editor, _| editor.scroll_offset()); + assert!(offset.y < px(0.0)); + for (destination, response_tab) in [ + ( + crate::shell::OpenTab::Request(request_key), + ResponseViewerTab::Headers, + ), + ( + crate::shell::OpenTab::Request(request_key), + ResponseViewerTab::Raw, + ), + ( + crate::shell::OpenTab::Overview(crate::shell::OverviewTab::Collection), + ResponseViewerTab::Pretty, + ), + ( + crate::shell::OpenTab::Request(other_request), + ResponseViewerTab::Pretty, + ), + ] { + window + .update(cx, |view, _, cx| { + view.select_open_tab(destination, cx); + view.set_response_tab(response_tab, cx); + }) + .unwrap(); + cx.run_until_parked(); + { + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_none()); + } + window + .update(cx, |view, _, cx| { + view.select_request(request_key, cx); + view.set_response_tab(ResponseViewerTab::Pretty, cx); + }) + .unwrap(); + cx.run_until_parked(); + { + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_some()); + } + window + .update(cx, |view, _, cx| { + let restored = view + .response_viewer + .editor(request_key, ResponseViewerTab::Pretty) + .editor(cx); + assert_eq!(restored, editor); + assert_eq!(restored.read(cx).scroll_offset(), offset); + assert_eq!(restored.read(cx).search_session().query, "ok"); + }) + .unwrap(); + } + // Returning to a tab preserves its open search without stealing focus. + { + let mut visual = VisualTestContext::from_window(window.into(), cx); + let input = visual.debug_bounds("editor-search-input").unwrap(); + visual.simulate_click(input.center(), Modifiers::default()); + } cx.simulate_keystrokes(window.into(), "escape"); cx.run_until_parked(); { diff --git a/crates/desktop/src/app/tests/workspace.rs b/crates/desktop/src/app/tests/workspace.rs index 84a02985..f52eb007 100644 --- a/crates/desktop/src/app/tests/workspace.rs +++ b/crates/desktop/src/app/tests/workspace.rs @@ -448,7 +448,8 @@ fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestApp .update(cx, |view, _, cx| { let key = view.shell.active_tab().unwrap(); view.request_editor.set_section(key, section); - view.request_section_scroll + view.request_editor + .scroll(key, section) .set_offset(point(px(0.0), px(0.0))); cx.notify(); }) @@ -480,13 +481,67 @@ fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestApp }); assert_eq!( window - .update(cx, |view, _, _| view.request_section_scroll.offset().y) + .update(cx, |view, _, _| view + .request_editor + .scroll(view.shell.active_tab().unwrap(), section) + .offset() + .y) .unwrap(), px(-8.0), "scroll wiring for {section:?}, value column: {value_column}" ); } } + let key = window + .update(cx, |view, _, cx| { + let key = view.shell.active_tab().unwrap(); + view.request_editor.set_section(key, EditorSection::Headers); + cx.notify(); + key + }) + .unwrap(); + visual.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.request_editor + .scroll(key, EditorSection::Headers) + .set_offset(point(px(0.0), px(-120.0))); + cx.notify(); + }) + .unwrap(); + visual.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.request_editor.set_section(key, EditorSection::Path); + cx.notify(); + }) + .unwrap(); + visual.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.request_editor.set_section(key, EditorSection::Headers); + cx.notify(); + }) + .unwrap(); + visual.run_until_parked(); + window + .update(cx, |view, _, _| { + assert_eq!( + view.request_editor + .scroll(key, EditorSection::Headers) + .offset() + .y, + px(-120.0) + ); + assert_eq!( + view.request_editor + .scroll(key, EditorSection::Path) + .offset() + .y, + px(-8.0) + ); + }) + .unwrap(); } #[gpui_kit::test] @@ -3936,7 +3991,7 @@ fn restored_active_tab_highlights_matching_sidebar_request(cx: &mut TestAppConte } #[gpui_kit::test] -fn workspace_reload_preserves_request_section_scroll_owner_after_multiple_remaps( +fn workspace_reload_preserves_request_section_scroll_after_multiple_remaps( cx: &mut TestAppContext, ) { cx.update(Theme::init); @@ -3956,8 +4011,9 @@ fn workspace_reload_preserves_request_section_scroll_owner_after_multiple_remaps view.request_editor .set_section(old_key, EditorSection::Headers); - view.request_section_scroll_owner - .set(Some((old_key, EditorSection::Headers))); + view.request_editor + .scroll(old_key, EditorSection::Headers) + .set_offset(point(px(0.0), px(-120.0))); }) .unwrap(); @@ -3965,13 +4021,18 @@ fn workspace_reload_preserves_request_section_scroll_owner_after_multiple_remaps window .update(cx, |view, _, _| { let old_key = view.shell.active_tab().unwrap(); + view.request_editor + .scroll(old_key, EditorSection::Headers) + .set_offset(point(px(0.0), px(-120.0))); let new_key = reload_unchanged_fixture(view, &fixture)[&old_key]; - let scroll_owner = view.request_section_scroll_owner.get(); assert_eq!( - scroll_owner, - Some((new_key, EditorSection::Headers)), - "scroll owner should be remapped after reload {iteration}" + view.request_editor + .scroll(new_key, EditorSection::Headers) + .offset() + .y, + px(-120.0), + "scroll position should be remapped after reload {iteration}" ); }) .unwrap(); diff --git a/crates/desktop/src/app/workspace.rs b/crates/desktop/src/app/workspace.rs index be901d23..d382d7ca 100644 --- a/crates/desktop/src/app/workspace.rs +++ b/crates/desktop/src/app/workspace.rs @@ -902,6 +902,7 @@ impl ProbeApp { } pub(super) fn reset_collection_ui(&mut self) { + self.overview_editors.get_mut().clear(); self.overview_drafts.clear(); self.pending_documentation_saves.clear(); self.documentation_save_task = None; @@ -1056,14 +1057,6 @@ impl ProbeApp { self.websocket.remap_requests(&remaps); self.response_viewer.remap_requests(&remaps); self.request_editor.remap_requests(&remaps); - if let Some((old_key, section)) = self.request_section_scroll_owner.get() { - self.request_section_scroll_owner.set( - remaps - .get(&old_key) - .copied() - .map(|new_key| (new_key, section)), - ); - } self.send_and_save_targets.retain(|_, key| { remaps.get(key).is_some_and(|new_key| { *key = *new_key; @@ -1191,6 +1184,7 @@ impl ProbeApp { let targets: BTreeMap<_, _> = self .overview_drafts .keys() + .chain(self.overview_editors.get_mut().keys()) .chain(self.pending_documentation_saves.iter()) .chain(match self.pending_close.as_ref() { Some(PendingClose::Overview(target)) => Some(target), @@ -1211,6 +1205,14 @@ impl ProbeApp { (target.clone(), mapped) }) .collect(); + *self.overview_editors.get_mut() = std::mem::take(self.overview_editors.get_mut()) + .into_iter() + .filter_map(|(target, editors)| { + let mapped = targets.get(&target)?; + (!matches!(mapped, OverviewTarget::DetachedFolder(_))) + .then(|| (mapped.clone(), editors)) + }) + .collect(); self.overview_drafts = std::mem::take(&mut self.overview_drafts) .into_iter() .map(|(target, draft)| (targets[&target].clone(), draft)) diff --git a/crates/desktop/src/components/components_tests.rs b/crates/desktop/src/components/components_tests.rs index bc96f822..e2444e88 100644 --- a/crates/desktop/src/components/components_tests.rs +++ b/crates/desktop/src/components/components_tests.rs @@ -743,6 +743,7 @@ impl Render for EditableEditorHarness { .flex_col() .child( ProbeEditor { + retained_state: None, theme, id: "editable-editor-regression".into(), value: self.value.clone(), @@ -991,6 +992,7 @@ impl Render for TextContextMenuHarness { input.into_any_element() } TextContextMenuHarnessKind::BodyEditor => ProbeEditor { + retained_state: None, theme, id: "context-body-editor".into(), value: "{\"ok\":true}".into(), @@ -1013,6 +1015,7 @@ impl Render for TextContextMenuHarness { } .into_any_element(), TextContextMenuHarnessKind::ResponseEditor => ProbeEditor { + retained_state: None, theme, id: "context-response-editor".into(), value: "{\"ok\":true}".into(), diff --git a/crates/desktop/src/components/editor.rs b/crates/desktop/src/components/editor.rs index 7ea40348..c0a1d1b5 100644 --- a/crates/desktop/src/components/editor.rs +++ b/crates/desktop/src/components/editor.rs @@ -11,7 +11,7 @@ mod variables; use core::ProbeEditor; #[cfg(test)] pub(super) use core::ProbeEditor; -pub(crate) use core::editor_paint_style; +pub(crate) use core::{RetainedEditorState, editor_paint_style}; pub(crate) use response::{ BodySyntax, body_text_input, curl_command_input, documentation_text_input, response_body_input, response_headers_input, response_inspector_input, websocket_composer, diff --git a/crates/desktop/src/components/editor/core.rs b/crates/desktop/src/components/editor/core.rs index d1fa438f..348d2f91 100644 --- a/crates/desktop/src/components/editor/core.rs +++ b/crates/desktop/src/components/editor/core.rs @@ -2,11 +2,36 @@ use super::*; use crate::app::{ShiftTabOrOutdent, TabOrIndent}; use gpui_kit::EntityInputHandler as _; +/// Keeps the native editor and search session alive while its tab or section is hidden. +#[derive(Clone, Debug, Default)] +pub(crate) struct RetainedEditorState(Rc>>); + +#[derive(Clone, Debug)] +struct EditorSession { + field: Entity, + search: Entity, +} + +impl RetainedEditorState { + #[cfg(test)] + pub(crate) fn editor(&self, cx: &App) -> Entity { + self.0 + .borrow() + .as_ref() + .expect("editor rendered") + .field + .read(cx) + .state + .clone() + } +} + struct EditorField { state: Entity, decorations: TextDecorationCollection, last_decorations: Vec, last_value: SharedString, + last_external_value: SharedString, on_change: Option, last_scroll_range: Option>, language: SharedString, @@ -59,6 +84,7 @@ pub(crate) fn editor_paint_style(theme: Theme) -> InputEditorStyle { #[derive(IntoElement)] pub(in crate::components) struct ProbeEditor { + pub(in crate::components) retained_state: Option, pub(in crate::components) theme: Theme, pub(in crate::components) id: ElementId, pub(in crate::components) value: SharedString, @@ -80,6 +106,25 @@ pub(in crate::components) struct ProbeEditor { pub(in crate::components) variables: Option, } +// Persistent sessions are owned by the tab, rather than by consecutive frames. +// Observe them in the same view as keyed state so editor events still redraw it. +fn session_state( + persistent: bool, + id: ElementId, + window: &mut Window, + cx: &mut App, + init: impl FnOnce(&mut Window, &mut Context) -> S, +) -> Entity { + if persistent { + let state = cx.new(|cx| init(window, cx)); + let view = window.current_view(); + cx.observe(&state, move |_, cx| cx.notify(view)).detach(); + state + } else { + window.use_keyed_state(id, cx, init) + } +} + impl RenderOnce for ProbeEditor { fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement { let component_id = self.id.clone(); @@ -100,53 +145,80 @@ impl RenderOnce for ProbeEditor { let soft_wrap = self.soft_wrap; let language = self.language.clone(); let editor_id = self.id.clone(); - let search_state = window.use_keyed_state( - ElementId::NamedChild( - Arc::new(editor_id.clone()), - SharedString::from("search-state"), - ), - cx, - |_, _| EditorSearchState::default(), - ); + let retained = self + .retained_state + .as_ref() + .and_then(|state| state.0.borrow().clone()); + let search_state = if let Some(session) = &retained { + session.search.clone() + } else { + session_state( + self.retained_state.is_some(), + ElementId::NamedChild( + Arc::new(editor_id.clone()), + SharedString::from("search-state"), + ), + window, + cx, + |_, _| EditorSearchState::default(), + ) + }; let scroll_to_range = self.scroll_to_range; - let field = window.use_keyed_state(self.id.clone(), cx, |window, cx| { - let state = cx.new(|cx| { - let mut editor = EditorState::new(window, cx) - .placeholder(placeholder.clone()) - // Kit 0.8 enables macOS bounce by default; keep Probe's - // existing request and response editor scrolling behavior. - .scroll_bounce(false) - .smart_indent(language.as_ref() == "json") - .folding(false) - // Let the shortcut reach Probe’s search card; the native - // session still owns matching, navigation, and painting. - .searchable(false) - .soft_wrap(soft_wrap) - .language(language.clone()); - editor.set_highlighter_factory(crate::syntax::factory(), cx); - editor.set_editor_style(paint_style.clone()); - editor - }); - state.update(cx, |editor, cx| { - editor.set_readonly(self.readonly, cx); - editor.set_value(self.value.clone(), window, cx); - }); - let decorations = state.update(cx, |editor, cx| { - editor.create_decorations_collection(Vec::new(), cx) + let field = if let Some(session) = retained { + session.field + } else { + session_state( + self.retained_state.is_some(), + self.id.clone(), + window, + cx, + |window, cx| { + let state = cx.new(|cx| { + let mut editor = EditorState::new(window, cx) + .placeholder(placeholder.clone()) + // Kit 0.8 enables macOS bounce by default; keep Probe's + // existing request and response editor scrolling behavior. + .scroll_bounce(false) + .smart_indent(language.as_ref() == "json") + .folding(false) + // Let the shortcut reach Probe’s search card; the native + // session still owns matching, navigation, and painting. + .searchable(false) + .soft_wrap(soft_wrap) + .language(language.clone()); + editor.set_highlighter_factory(crate::syntax::factory(), cx); + editor.set_editor_style(paint_style.clone()); + editor + }); + state.update(cx, |editor, cx| { + editor.set_readonly(self.readonly, cx); + editor.set_value(self.value.clone(), window, cx); + }); + let decorations = state.update(cx, |editor, cx| { + editor.create_decorations_collection(Vec::new(), cx) + }); + let subscription = cx.subscribe_in(&state, window, EditorField::on_event); + EditorField { + state, + decorations, + last_decorations: Vec::new(), + last_value: self.value.clone(), + last_external_value: self.value.clone(), + on_change: on_change.clone(), + last_scroll_range: None, + language: language.clone(), + soft_wrap, + _subscription: subscription, + } + }, + ) + }; + if let Some(retained) = self.retained_state { + *retained.0.borrow_mut() = Some(EditorSession { + field: field.clone(), + search: search_state.clone(), }); - let subscription = cx.subscribe_in(&state, window, EditorField::on_event); - EditorField { - state, - decorations, - last_decorations: Vec::new(), - last_value: self.value.clone(), - on_change: on_change.clone(), - last_scroll_range: None, - language: language.clone(), - soft_wrap, - _subscription: subscription, - } - }); + } field.update(cx, |field, cx| { field.on_change = self.on_change.clone(); let language_changed = field.language != self.language; @@ -158,9 +230,13 @@ impl RenderOnce for ProbeEditor { field.soft_wrap = self.soft_wrap; } let context_focus = field.state.read(cx).focus_handle(cx); - let open_context_menu = context_menu.clone(); - let context_editor = field.state.clone(); - let value_changed = field.last_value != self.value; + let open_context_menu = context_menu.downgrade(); + let context_editor = field.state.downgrade(); + // A rejected/incomplete draft (for example GraphQL variables while + // typing JSON) must survive remounts when the model has not changed. + let value_changed = + field.last_value != self.value && field.last_external_value != self.value; + field.last_external_value = self.value.clone(); if value_changed { field.last_value = self.value.clone(); } @@ -175,6 +251,11 @@ impl RenderOnce for ProbeEditor { editor.set_soft_wrap(self.soft_wrap, window, cx); } editor.on_context_menu(Rc::new(move |_, capabilities, position, window, cx| { + let (Some(open_context_menu), Some(context_editor)) = + (open_context_menu.upgrade(), context_editor.upgrade()) + else { + return; + }; context_focus.focus(window, cx); open_context_menu.update(cx, |state, cx| { state.position = Some(position); diff --git a/crates/desktop/src/components/editor/native_tests.rs b/crates/desktop/src/components/editor/native_tests.rs index 90721487..2c9008d8 100644 --- a/crates/desktop/src/components/editor/native_tests.rs +++ b/crates/desktop/src/components/editor/native_tests.rs @@ -14,6 +14,7 @@ impl Render for EditorHarness { fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { let view = cx.weak_entity(); let element = ProbeEditor { + retained_state: None, theme: Theme::light(), id: "native-editor-test".into(), value: self.value.clone(), diff --git a/crates/desktop/src/components/editor/response.rs b/crates/desktop/src/components/editor/response.rs index 22ba8a40..f0d4efbe 100644 --- a/crates/desktop/src/components/editor/response.rs +++ b/crates/desktop/src/components/editor/response.rs @@ -19,12 +19,14 @@ pub(crate) enum BodySyntax { pub(crate) fn documentation_text_input( theme: Theme, + retained_state: Option, id: ElementId, value: String, placeholder: &'static str, on_value_change: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state, theme, id, value: value.into(), @@ -56,6 +58,7 @@ pub(crate) fn curl_command_input( on_value_change: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state: None, theme, id, value: value.into(), @@ -81,6 +84,7 @@ pub(crate) fn curl_command_input( pub(crate) fn websocket_composer( theme: Theme, + retained_state: RetainedEditorState, id: ElementId, value: String, enabled: bool, @@ -88,6 +92,7 @@ pub(crate) fn websocket_composer( on_change: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state: Some(retained_state), theme, id, value: value.into(), @@ -118,6 +123,7 @@ pub(crate) fn websocket_composer( pub(crate) fn body_text_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, value: impl Into, syntax: BodySyntax, @@ -133,6 +139,7 @@ pub(crate) fn body_text_input( |kind, name| placeholder_tone(&variables, kind, name), ); ProbeEditor { + retained_state: Some(retained_state), theme, id: id.into(), value, @@ -162,6 +169,7 @@ pub(crate) fn body_text_input( pub(crate) fn response_body_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, text: SharedString, options: ResponseBodyInputOptions, @@ -234,6 +242,7 @@ pub(crate) fn response_body_input( response_editor( theme, + retained_state, id, ResponseEditorPresentation { value: text, @@ -268,6 +277,7 @@ fn cached_value_at_cursor( pub(crate) fn response_headers_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, headers: &[probe_http::ResponseHeader], on_visible_range: impl Fn(Range, &mut App) + 'static, @@ -283,6 +293,7 @@ pub(crate) fn response_headers_input( } response_editor( theme, + retained_state, id, ResponseEditorPresentation { value: joined.text.into(), @@ -300,12 +311,14 @@ pub(crate) fn response_headers_input( pub(crate) fn response_inspector_input( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, text: impl Into, on_visible_range: impl Fn(Range, &mut App) + 'static, ) -> gpui_kit::AnyElement { response_editor( theme, + retained_state, id, ResponseEditorPresentation { value: text.into(), @@ -332,6 +345,7 @@ struct ResponseEditorPresentation { fn response_editor( theme: Theme, + retained_state: RetainedEditorState, id: impl Into, presentation: ResponseEditorPresentation, on_visible_range: VisibleRangeHandler, @@ -339,6 +353,7 @@ fn response_editor( extra_context_menu_actions: Vec, ) -> gpui_kit::AnyElement { ProbeEditor { + retained_state: Some(retained_state), theme, id: id.into(), value: presentation.value, diff --git a/crates/desktop/src/components/mod.rs b/crates/desktop/src/components/mod.rs index 331f221f..7b3ea29c 100644 --- a/crates/desktop/src/components/mod.rs +++ b/crates/desktop/src/components/mod.rs @@ -119,3 +119,5 @@ pub(crate) fn menu_leading_slot(width: f32, content: impl IntoElement) -> gpui_k #[cfg(test)] mod components_tests; + +pub(crate) use editor::RetainedEditorState; diff --git a/crates/desktop/src/request_editor.rs b/crates/desktop/src/request_editor.rs index 1db51318..77edd586 100644 --- a/crates/desktop/src/request_editor.rs +++ b/crates/desktop/src/request_editor.rs @@ -1,5 +1,5 @@ use std::{ - cell::Cell, + cell::{Cell, RefCell}, collections::{BTreeMap, HashMap}, }; @@ -107,7 +107,7 @@ impl AssertionEdit { } } -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, PartialEq, PartialOrd)] pub(crate) enum EditorSection { #[default] Path, @@ -305,12 +305,36 @@ const fn hex(byte: u8) -> Option { #[derive(Debug, Default)] pub(crate) struct RequestEditorState { sections: HashMap, + editors: RefCell>, + scrolls: RefCell>, assertion_focus: Cell>, body_drafts: BTreeMap<(RequestKey, BodyEditorKind), RequestBody>, } impl RequestEditorState { + pub(crate) fn editor( + &self, + key: RequestKey, + slot: &'static str, + ) -> crate::components::RetainedEditorState { + self.editors + .borrow_mut() + .entry((key, slot)) + .or_default() + .clone() + } + + pub(crate) fn scroll(&self, key: RequestKey, section: EditorSection) -> gpui_kit::ScrollHandle { + self.scrolls + .borrow_mut() + .entry((key, section)) + .or_default() + .clone() + } + pub(crate) fn clear(&mut self) { + self.editors.get_mut().clear(); + self.scrolls.get_mut().clear(); self.sections.clear(); self.assertion_focus.set(None); self.body_drafts.clear(); @@ -340,6 +364,8 @@ impl RequestEditorState { } pub(crate) fn remove(&mut self, key: RequestKey) { + self.editors.get_mut().retain(|(owner, _), _| *owner != key); + self.scrolls.get_mut().retain(|(owner, _), _| *owner != key); self.sections.remove(&key); if self .assertion_focus @@ -369,6 +395,16 @@ impl RequestEditorState { } pub(crate) fn remap_requests(&mut self, keys: &BTreeMap) { + *self.editors.get_mut() = std::mem::take(self.editors.get_mut()) + .into_iter() + .filter_map(|((key, slot), editor)| keys.get(&key).map(|new| ((*new, slot), editor))) + .collect(); + *self.scrolls.get_mut() = std::mem::take(self.scrolls.get_mut()) + .into_iter() + .filter_map(|((key, section), scroll)| { + keys.get(&key).map(|new| ((*new, section), scroll)) + }) + .collect(); self.assertion_focus.set( self.assertion_focus .get() diff --git a/crates/desktop/src/response_viewer/mod.rs b/crates/desktop/src/response_viewer/mod.rs index 65d50c64..56718a8a 100644 --- a/crates/desktop/src/response_viewer/mod.rs +++ b/crates/desktop/src/response_viewer/mod.rs @@ -164,6 +164,10 @@ pub(crate) struct ResponseViewerState { selections: std::collections::HashMap, documents: std::collections::BTreeMap, image_scrolls: std::collections::BTreeMap, + editors: std::collections::BTreeMap< + probe_core::RequestKey, + [crate::components::RetainedEditorState; 6], + >, next_generation: u64, } @@ -172,9 +176,32 @@ struct ResponseSelection { tab: ResponseViewerTab, raw_view: RawBodyView, assertion_scroll: ScrollHandle, + inspector_scroll: gpui_kit::UniformListScrollHandle, } impl ResponseViewerState { + pub(crate) fn editor( + &self, + key: probe_core::RequestKey, + tab: ResponseViewerTab, + ) -> crate::components::RetainedEditorState { + let index = match tab { + ResponseViewerTab::Pretty => 0, + ResponseViewerTab::Raw => match self.raw_view(key) { + RawBodyView::Text => 1, + RawBodyView::Base64 => 2, + RawBodyView::Hex => 3, + }, + ResponseViewerTab::Headers => 4, + ResponseViewerTab::Inspect => 5, + ResponseViewerTab::Assertions => unreachable!("assertions do not use a text editor"), + }; + self.editors + .get(&key) + .expect("response document owns editor state")[index] + .clone() + } + pub(crate) fn tab(&self, key: probe_core::RequestKey) -> ResponseViewerTab { self.selections .get(&key) @@ -193,6 +220,17 @@ impl ResponseViewerState { self.documents.get(&key) } + pub(crate) fn inspector_scroll( + &self, + key: probe_core::RequestKey, + ) -> &gpui_kit::UniformListScrollHandle { + &self + .selections + .get(&key) + .expect("response owns a selection") + .inspector_scroll + } + pub(crate) fn image_scroll(&self, key: probe_core::RequestKey) -> Option<&ScrollHandle> { self.image_scrolls.get(&key) } @@ -219,6 +257,8 @@ impl ResponseViewerState { } else { self.image_scrolls.remove(&key); } + self.selections.entry(key).or_default().inspector_scroll = Default::default(); + self.editors.insert(key, Default::default()); self.documents.insert(key, document); } @@ -236,10 +276,12 @@ impl ResponseViewerState { } pub(crate) fn remove(&mut self, key: probe_core::RequestKey) { + self.editors.remove(&key); self.documents.remove(&key); self.image_scrolls.remove(&key); if let Some(selection) = self.selections.get_mut(&key) { selection.assertion_scroll = ScrollHandle::new(); + selection.inspector_scroll = Default::default(); } } @@ -249,6 +291,7 @@ impl ResponseViewerState { pub(crate) fn clear(&mut self) { self.selections.clear(); + self.editors.clear(); self.documents.clear(); self.image_scrolls.clear(); } @@ -257,6 +300,10 @@ impl ResponseViewerState { &mut self, key_remaps: &std::collections::BTreeMap, ) { + self.editors = std::mem::take(&mut self.editors) + .into_iter() + .filter_map(|(key, editors)| key_remaps.get(&key).map(|new| (*new, editors))) + .collect(); self.selections = std::mem::take(&mut self.selections) .into_iter() .filter_map(|(key, selection)| key_remaps.get(&key).map(|new| (*new, selection))) diff --git a/crates/desktop/src/response_viewer/tests.rs b/crates/desktop/src/response_viewer/tests.rs index 7c061ad8..e99f489c 100644 --- a/crates/desktop/src/response_viewer/tests.rs +++ b/crates/desktop/src/response_viewer/tests.rs @@ -696,3 +696,61 @@ fn results_for_replaced_or_closed_documents_are_ignored_after_a_reload() { assert!(viewer.document(old_key).is_none()); assert!(viewer.document(new_key).is_none()); } + +#[test] +fn inspector_scroll_is_per_request_survives_remaps_and_resets_with_response() { + use gpui_kit::{point, px}; + use std::{collections::BTreeMap, rc::Rc}; + let first = request_key(); + let second = replacement_request_key(); + let document = prepare_document(&response(b"body", "text/plain"), 1).0; + let mut viewer = super::ResponseViewerState::default(); + viewer.insert(first, document.clone()); + viewer.insert(second, document.clone()); + let first_scroll = viewer.inspector_scroll(first).clone(); + first_scroll + .0 + .borrow() + .base_handle + .set_offset(point(px(0.0), px(-120.0))); + assert_eq!( + viewer + .inspector_scroll(second) + .0 + .borrow() + .base_handle + .offset() + .y, + px(0.0) + ); + viewer.remap_requests(&BTreeMap::from([(first, second)])); + assert!(Rc::ptr_eq( + &first_scroll.0, + &viewer.inspector_scroll(second).0 + )); + assert_eq!( + viewer + .inspector_scroll(second) + .0 + .borrow() + .base_handle + .offset() + .y, + px(-120.0) + ); + viewer.insert(second, document); + assert_eq!( + viewer + .inspector_scroll(second) + .0 + .borrow() + .base_handle + .offset() + .y, + px(0.0) + ); + assert!(!Rc::ptr_eq( + &first_scroll.0, + &viewer.inspector_scroll(second).0 + )); +} From 7550684f3d0f1ef31a62a9673c16ed3c103f4033 Mon Sep 17 00:00:00 2001 From: Crizant Lai Date: Tue, 3 Nov 2026 13:37:24 +1000 Subject: [PATCH 2/4] fix(desktop): reset stale editor sessions on reload --- crates/desktop/src/app/tests/editor_state.rs | 339 ++++++++++--------- crates/desktop/src/app/tests/response.rs | 72 ++-- crates/desktop/src/app/tests/workspace.rs | 101 +++--- crates/desktop/src/app/workspace.rs | 20 ++ crates/desktop/src/request_editor.rs | 6 +- crates/desktop/src/response_viewer/tests.rs | 68 ++-- 6 files changed, 318 insertions(+), 288 deletions(-) diff --git a/crates/desktop/src/app/tests/editor_state.rs b/crates/desktop/src/app/tests/editor_state.rs index 693caf45..5c54d75c 100644 --- a/crates/desktop/src/app/tests/editor_state.rs +++ b/crates/desktop/src/app/tests/editor_state.rs @@ -1,11 +1,37 @@ use super::*; -use gpui_kit::base::input::EditorState; +use gpui_kit::{Entity, WindowHandle, base::input::EditorState}; use probe_core::{ - Body, GraphqlBody, GraphqlOperation, RawBody, RawBodyKind, RequestBody, RequestKind, + Body, GraphqlBody, GraphqlBodyVariant, GraphqlOperation, RawBody, RawBodyKind, RequestBody, + RequestKind, }; -#[gpui_kit::test] -fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppContext) { +fn select_editor( + window: WindowHandle, + key: probe_core::RequestKey, + section: EditorSection, + slot: &'static str, + cx: &mut TestAppContext, +) -> Entity { + window + .update(cx, |view, _, cx| { + view.select_request(key, cx); + view.request_editor.set_section(key, section); + cx.notify(); + }) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, window, cx| { + let editor = view.request_editor.editor(key, slot).editor(cx); + editor.update(cx, |editor, cx| editor.focus(window, cx)); + editor + }) + .unwrap() +} + +fn editor_workspace( + cx: &mut TestAppContext, +) -> (WindowHandle, [probe_core::RequestKey; 3]) { cx.update(Theme::init); cx.update(bind_platform_hotkeys); let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); @@ -21,21 +47,28 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo }))), }; request.docs = Some(text.clone()); - let object = serde_json::from_value(serde_json::json!({"rows": vec!["needle"; 100]})).unwrap(); - let graphql = workspace.add_detached_request(Request { - kind: RequestKind::Graphql { - body: Some(GraphqlBody::Single(GraphqlOperation { - query: Some(text.clone()), - variables: Some(object), - extensions: Some( - serde_json::from_value(serde_json::json!({"rows": vec!["needle"; 100]})) - .unwrap(), - ), - ..Default::default() - })), - }, + let object = serde_json::from_value::>( + serde_json::json!({"rows": vec!["needle"; 100]}), + ) + .unwrap(); + let operation = GraphqlOperation { + query: Some(text.clone()), + variables: Some(object.clone()), + extensions: Some(object), ..Default::default() - }); + }; + let graphql = workspace.requests()[1].key(); + workspace.request_mut(graphql).unwrap().kind = RequestKind::Graphql { + body: Some(GraphqlBody::Variants( + [true, false] + .map(|selected| GraphqlBodyVariant { + title: "Same title".into(), + selected, + body: operation.clone(), + }) + .into(), + )), + }; let websocket = workspace.add_detached_request(Request { kind: RequestKind::WebSocket { message: Some(probe_core::WebSocketMessageSet::Single( @@ -61,6 +94,12 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo .unwrap(); cx.run_until_parked(); + (window, [http, graphql, websocket]) +} + +#[gpui_kit::test] +fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppContext) { + let (window, [http, graphql, websocket]) = editor_workspace(cx); for (key, section, slot) in [ (http, EditorSection::Body, "body-text"), (http, EditorSection::Docs, "request-docs"), @@ -86,132 +125,36 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo "websocket-composer", ), ] { + let editor = select_editor(window, key, section, slot, cx); + editor.update(cx, |editor, cx| editor.set_selected_range(0..6, cx)); + // Unmount the section, then leave the request. Each editor must retain + // its session through both transitions; restore it only once. window .update(cx, |view, _, cx| { - view.select_request(key, cx); - view.request_editor.set_section(key, section); + view.request_editor.set_section(key, EditorSection::Headers); cx.notify(); }) .unwrap(); cx.run_until_parked(); - let editor = window - .update(cx, |view, window, cx| { - let editor = view.request_editor.editor(key, slot).editor(cx); - editor.update(cx, |editor, cx| { - editor.set_selected_range(0..0, cx); - editor.focus(window, cx); - }); - editor - }) - .unwrap(); - cx.simulate_keystrokes(window.into(), find_shortcut()); - cx.simulate_input(window.into(), "needle"); - cx.run_until_parked(); - editor.update(cx, |editor: &mut EditorState, cx| { - editor.next_search_match(cx); - }); - cx.run_until_parked(); - editor.update(cx, |editor, cx| { - editor.set_scroll_offset(point(px(0.0), px(-100.0)), cx) - }); - cx.run_until_parked(); - let before = editor.read_with(cx, |editor, _| { - ( - editor.scroll_offset(), - editor.selected_range(), - editor.search_session().matcher.current_match_index(), - ) - }); - assert!(before.0.y < px(0.0), "{slot} should be scrolled"); - // Both section switches and request switches unmount the editor. - for other in [false, true] { - window - .update(cx, |view, _, cx| { - if other { - view.select_request(if key == http { graphql } else { http }, cx); - } else { - view.request_editor.set_section(key, EditorSection::Headers); - cx.notify(); - } - }) - .unwrap(); - cx.run_until_parked(); - window - .update(cx, |view, _, cx| { - view.select_request(key, cx); - view.request_editor.set_section(key, section); - cx.notify(); - }) - .unwrap(); - cx.run_until_parked(); - window - .update(cx, |view, _, cx| { - assert_eq!(view.request_editor.editor(key, slot).editor(cx), editor); - let state = editor.read(cx); - assert_eq!(state.scroll_offset(), before.0, "{slot}"); - assert_eq!(state.selected_range(), before.1, "{slot}"); - assert_eq!(state.search_session().query, "needle", "{slot}"); - assert_eq!( - state.search_session().matcher.current_match_index(), - before.2, - "{slot}" - ); - }) - .unwrap(); - let mut visual = VisualTestContext::from_window(window.into(), cx); - assert!( - visual.debug_bounds("editor-search-card").is_some(), - "{slot}" - ); - } - // Close this search so another editor in the same request can be checked independently. window - .update(cx, |_, window, cx| { - editor.update(cx, |editor, cx| editor.focus(window, cx)) + .update(cx, |view, _, cx| { + view.select_request(if key == http { graphql } else { http }, cx); }) .unwrap(); - cx.simulate_keystrokes(window.into(), "escape"); cx.run_until_parked(); + assert_eq!(select_editor(window, key, section, slot, cx), editor); + assert_eq!( + editor.read_with(cx, |state, _| state.selected_range()), + 0..6, + "{slot}" + ); } - // Incomplete JSON is a local draft; the last valid model value must not replace it. + let editor = select_editor(window, http, EditorSection::Body, "body-text", cx); + let weak = editor.downgrade(); + drop(editor); window .update(cx, |view, _, cx| { - view.select_request(graphql, cx); - view.request_editor - .set_section(graphql, EditorSection::GraphqlVariables); - cx.notify(); - }) - .unwrap(); - cx.run_until_parked(); - let variables = window - .update(cx, |view, window, cx| { - let editor = view - .request_editor - .editor(graphql, "graphql-variables") - .editor(cx); - editor.update(cx, |editor, cx| { - editor.set_selected_range(0..editor.value().len(), cx); - editor.focus(window, cx); - }); - editor - }) - .unwrap(); - cx.simulate_input(window.into(), "{"); - cx.run_until_parked(); - window - .update(cx, |view, _, cx| view.select_request(http, cx)) - .unwrap(); - cx.run_until_parked(); - window - .update(cx, |view, _, cx| view.select_request(graphql, cx)) - .unwrap(); - cx.run_until_parked(); - assert_eq!(variables.read_with(cx, |editor, _| editor.value()), "{"); - let weak = variables.downgrade(); - drop(variables); - window - .update(cx, |view, _, cx| { - view.remove_open_tab(crate::shell::OpenTab::Request(graphql)); + view.remove_open_tab(crate::shell::OpenTab::Request(http)); cx.notify(); }) .unwrap(); @@ -223,18 +166,11 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo } #[gpui_kit::test] -fn overview_editor_keeps_undo_and_search_until_closed(cx: &mut TestAppContext) { - cx.update(Theme::init); - cx.update(bind_platform_hotkeys); - let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); - let fixture = bundled_fixture(); - let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); - let request = workspace.requests()[0].key(); +fn overview_editor_keeps_session_until_closed(cx: &mut TestAppContext) { + let (window, [request, ..]) = editor_workspace(cx); let overview = crate::shell::OverviewTab::Collection; window .update(cx, |view, _, cx| { - view.session_store = None; - view.set_workspace(fixture, workspace); view.select_open_tab(crate::shell::OpenTab::Overview(overview), cx); }) .unwrap(); @@ -247,11 +183,9 @@ fn overview_editor_keeps_undo_and_search_until_closed(cx: &mut TestAppContext) { editor }) .unwrap(); - let original = editor.read_with(cx, |editor, _| editor.value()); cx.simulate_input(window.into(), "additional documentation"); cx.run_until_parked(); - cx.simulate_keystrokes(window.into(), find_shortcut()); - cx.run_until_parked(); + let selection = editor.read_with(cx, |editor, _| editor.selected_range()); window .update(cx, |view, _, cx| view.select_request(request, cx)) .unwrap(); @@ -262,26 +196,13 @@ fn overview_editor_keeps_undo_and_search_until_closed(cx: &mut TestAppContext) { }) .unwrap(); cx.run_until_parked(); - { - let mut visual = VisualTestContext::from_window(window.into(), cx); - assert!(visual.debug_bounds("editor-search-card").is_some()); - } window - .update(cx, |_, window, cx| { - editor.update(cx, |editor, cx| editor.focus(window, cx)) + .read_with(cx, |view, cx| { + let restored = view.overview_editors.borrow()[&target][1].editor(cx); + assert_eq!(restored, editor); + assert_eq!(restored.read(cx).selected_range(), selection); }) .unwrap(); - cx.simulate_keystrokes(window.into(), "escape"); - cx.simulate_keystrokes( - window.into(), - if cfg!(target_os = "macos") { - "cmd-z" - } else { - "ctrl-z" - }, - ); - cx.run_until_parked(); - assert_eq!(editor.read_with(cx, |editor, _| editor.value()), original); window .update(cx, |view, _, _| { view.remove_open_tab(crate::shell::OpenTab::Overview(overview)); @@ -289,3 +210,101 @@ fn overview_editor_keeps_undo_and_search_until_closed(cx: &mut TestAppContext) { }) .unwrap(); } + +#[gpui_kit::test] +fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mut TestAppContext) { + let (window, [_, key, _]) = editor_workspace(cx); + let fixture = bundled_fixture(); + let mut editors = Vec::new(); + for (section, slot) in [ + (EditorSection::GraphqlQuery, "graphql-query"), + (EditorSection::GraphqlVariables, "graphql-variables"), + (EditorSection::GraphqlExtensions, "graphql-extensions"), + ] { + let editor = select_editor(window, key, section, slot, cx); + if section != EditorSection::GraphqlQuery { + editor.update(cx, |editor, cx| { + editor.set_selected_range(0..editor.value().len(), cx) + }); + } + cx.simulate_input( + window.into(), + if section == EditorSection::GraphqlQuery { + "edited" + } else { + "invalid" + }, + ); + cx.run_until_parked(); + editors.push((section, slot, editor)); + } + let expected_query = editors[0].2.read_with(cx, |editor, _| editor.value()); + for change in 0..3 { + let changed = change != 0; + let key = window + .update(cx, |view, _, cx| { + let mut fresh = probe_opencollection::load_workspace(&fixture).unwrap(); + let current = view.loaded_workspace.as_ref().unwrap(); + let mut kind = current + .workspace() + .request(current.requests()[1].key()) + .unwrap() + .kind + .clone(); + if changed + && let RequestKind::Graphql { + body: Some(GraphqlBody::Variants(variants)), + } = &mut kind + { + // The new operation has identical text and a duplicate title. + if change == 1 { + variants[1].body = variants[0].body.clone(); + variants[0].selected = false; + variants[1].selected = true; + } else { + variants[1].body.operation_name = Some("Changed".into()); + } + } + let key = fresh.requests()[1].key(); + fresh.request_mut(key).unwrap().kind = kind; + view.apply_reconciled_workspace(reconciled_workspace(fresh), cx); + key + }) + .unwrap(); + for (section, slot, previous) in &mut editors { + let restored = select_editor(window, key, *section, slot, cx); + assert_eq!(restored == *previous, !changed, "{slot}"); + *previous = restored.clone(); + if *section == EditorSection::GraphqlQuery { + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx); + }) + .unwrap(); + cx.run_until_parked(); + if !changed { + assert_ne!( + restored.read_with(cx, |editor, _| editor.value()), + expected_query + ); + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Redo), cx); + }) + .unwrap(); + cx.run_until_parked(); + } + assert_eq!( + restored.read_with(cx, |editor, _| editor.value()), + expected_query + ); + } else { + assert_eq!( + restored.read_with(cx, |editor, _| editor.value()) == "invalid", + !changed, + "{slot}" + ); + } + } + } +} diff --git a/crates/desktop/src/app/tests/response.rs b/crates/desktop/src/app/tests/response.rs index 3877a40c..6294400e 100644 --- a/crates/desktop/src/app/tests/response.rs +++ b/crates/desktop/src/app/tests/response.rs @@ -502,58 +502,42 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont cx.run_until_parked(); let offset = editor.read_with(cx, |editor, _| editor.scroll_offset()); assert!(offset.y < px(0.0)); - for (destination, response_tab) in [ - ( - crate::shell::OpenTab::Request(request_key), - ResponseViewerTab::Headers, - ), - ( - crate::shell::OpenTab::Request(request_key), - ResponseViewerTab::Raw, - ), - ( - crate::shell::OpenTab::Overview(crate::shell::OverviewTab::Collection), - ResponseViewerTab::Pretty, - ), - ( - crate::shell::OpenTab::Request(other_request), - ResponseViewerTab::Pretty, - ), - ] { + for response_tab in [ResponseViewerTab::Raw, ResponseViewerTab::Headers] { window - .update(cx, |view, _, cx| { - view.select_open_tab(destination, cx); - view.set_response_tab(response_tab, cx); - }) + .update(cx, |view, _, cx| view.set_response_tab(response_tab, cx)) .unwrap(); cx.run_until_parked(); { let mut visual = VisualTestContext::from_window(window.into(), cx); assert!(visual.debug_bounds("editor-search-card").is_none()); } - window - .update(cx, |view, _, cx| { - view.select_request(request_key, cx); - view.set_response_tab(ResponseViewerTab::Pretty, cx); - }) - .unwrap(); - cx.run_until_parked(); - { - let mut visual = VisualTestContext::from_window(window.into(), cx); - assert!(visual.debug_bounds("editor-search-card").is_some()); - } - window - .update(cx, |view, _, cx| { - let restored = view - .response_viewer - .editor(request_key, ResponseViewerTab::Pretty) - .editor(cx); - assert_eq!(restored, editor); - assert_eq!(restored.read(cx).scroll_offset(), offset); - assert_eq!(restored.read(cx).search_session().query, "ok"); - }) - .unwrap(); } + window + .update(cx, |view, _, cx| view.select_request(other_request, cx)) + .unwrap(); + cx.run_until_parked(); + window + .update(cx, |view, _, cx| { + view.select_request(request_key, cx); + view.set_response_tab(ResponseViewerTab::Pretty, cx); + }) + .unwrap(); + cx.run_until_parked(); + { + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_some()); + } + window + .update(cx, |view, _, cx| { + let restored = view + .response_viewer + .editor(request_key, ResponseViewerTab::Pretty) + .editor(cx); + assert_eq!(restored, editor); + assert_eq!(restored.read(cx).scroll_offset(), offset); + assert_eq!(restored.read(cx).search_session().query, "ok"); + }) + .unwrap(); // Returning to a tab preserves its open search without stealing focus. { let mut visual = VisualTestContext::from_window(window.into(), cx); diff --git a/crates/desktop/src/app/tests/workspace.rs b/crates/desktop/src/app/tests/workspace.rs index f52eb007..c197527a 100644 --- a/crates/desktop/src/app/tests/workspace.rs +++ b/crates/desktop/src/app/tests/workspace.rs @@ -492,54 +492,40 @@ fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestApp ); } } - let key = window - .update(cx, |view, _, cx| { - let key = view.shell.active_tab().unwrap(); - view.request_editor.set_section(key, EditorSection::Headers); - cx.notify(); - key + let (key, other) = window + .read_with(cx, |view, _| { + ( + view.shell.active_tab().unwrap(), + view.loaded_workspace.as_ref().unwrap().requests()[0].key(), + ) }) .unwrap(); - visual.run_until_parked(); window .update(cx, |view, _, cx| { view.request_editor .scroll(key, EditorSection::Headers) .set_offset(point(px(0.0), px(-120.0))); - cx.notify(); - }) - .unwrap(); - visual.run_until_parked(); - window - .update(cx, |view, _, cx| { - view.request_editor.set_section(key, EditorSection::Path); - cx.notify(); + view.select_request(other, cx); + view.request_editor + .set_section(other, EditorSection::Headers); }) .unwrap(); visual.run_until_parked(); window .update(cx, |view, _, cx| { + let other_headers = view.request_editor.scroll(other, EditorSection::Headers); + assert_eq!(other_headers.offset().y, px(0.0)); + view.select_request(key, cx); view.request_editor.set_section(key, EditorSection::Headers); - cx.notify(); }) .unwrap(); visual.run_until_parked(); window - .update(cx, |view, _, _| { - assert_eq!( - view.request_editor - .scroll(key, EditorSection::Headers) - .offset() - .y, - px(-120.0) - ); - assert_eq!( - view.request_editor - .scroll(key, EditorSection::Path) - .offset() - .y, - px(-8.0) - ); + .read_with(cx, |view, _| { + let headers = view.request_editor.scroll(key, EditorSection::Headers); + let path = view.request_editor.scroll(key, EditorSection::Path); + assert_eq!(headers.offset().y, px(-120.0)); + assert_eq!(path.offset().y, px(-8.0)); }) .unwrap(); } @@ -3202,6 +3188,16 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( ProbeApp::new(window, cx) }); let fixture = writable_bundled_fixture("filesystem-reload"); + // Keep the GraphQL body unchanged on disk, so Use Disk must reset a + // rejected variables draft even though its model value never changed. + let source = fs::read_to_string(&fixture).unwrap(); + fs::write( + &fixture, + source + .replacen("type: http", "type: graphql", 1) + .replacen("http:", "graphql:", 1), + ) + .unwrap(); let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); let selector = workspace.requests()[0].selector().to_owned(); let key = workspace.requests()[0].key(); @@ -3209,6 +3205,9 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( .update(cx, |view, _, cx| { view.session_store = None; view.set_workspace(fixture.clone(), workspace); + view.select_request(key, cx); + view.request_editor + .set_section(key, EditorSection::GraphqlVariables); view.edit_request( key, |request| request.url = Some("https://local.example/draft".to_owned()), @@ -3217,6 +3216,19 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( }) .unwrap(); + cx.run_until_parked(); + let variables = window + .update(cx, |view, window, cx| { + let editor = view + .request_editor + .editor(key, "graphql-variables") + .editor(cx); + editor.update(cx, |editor, cx| editor.focus(window, cx)); + editor + }) + .unwrap(); + cx.simulate_input(window.into(), "invalid"); + cx.run_until_parked(); let source = fs::read_to_string(&fixture).unwrap(); fs::write(&fixture, source.replacen("method: GET", "method: PATCH", 1)).unwrap(); let fresh = probe_opencollection::load_workspace(&fixture).unwrap(); @@ -3249,19 +3261,33 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( view.application_dialog, Some(ApplicationDialog::FilesystemConflict { .. }) )); + let active = view.shell.active_tab().unwrap(); + assert_eq!( + view.request_editor + .editor(active, "graphql-variables") + .editor(cx), + variables + ); + assert_eq!(variables.read(cx).value(), "invalid"); view.handle_application_dialog_action(ApplicationDialogAction::UseDisk, window, cx); }) .unwrap(); cx.run_until_parked(); window - .update(cx, |view, _, _| { + .update(cx, |view, _, cx| { let loaded = view.loaded_workspace.as_ref().unwrap(); let key = loaded.request_key(&selector).unwrap(); let request = loaded.workspace().request(key).unwrap(); assert_eq!(request.method.as_deref(), Some("PUT")); assert_eq!(request.url.as_deref(), Some("https://api.example.com/pets")); assert!(!view.persistence.is_dirty(key, request)); + let restored = view + .request_editor + .editor(key, "graphql-variables") + .editor(cx); + assert_ne!(restored, variables); + assert_eq!(restored.read(cx).value(), ""); }) .unwrap(); fs::remove_file(fixture).unwrap(); @@ -3995,9 +4021,7 @@ fn workspace_reload_preserves_request_section_scroll_after_multiple_remaps( cx: &mut TestAppContext, ) { cx.update(Theme::init); - let window = cx.open_window(size(px(900.0), px(640.0)), |window, cx| { - ProbeApp::new(window, cx) - }); + let window = cx.open_window(size(px(900.0), px(640.0)), ProbeApp::new); let fixture = writable_bundled_fixture("reload-scroll-owner-multi"); let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); window @@ -4005,15 +4029,10 @@ fn workspace_reload_preserves_request_section_scroll_after_multiple_remaps( view.session_store = None; view.set_workspace(fixture.clone(), workspace); - let old = view.loaded_workspace.as_ref().unwrap(); - let old_key = old.requests()[0].key(); + let old_key = view.loaded_workspace.as_ref().unwrap().requests()[0].key(); view.select_request(old_key, cx); view.request_editor .set_section(old_key, EditorSection::Headers); - - view.request_editor - .scroll(old_key, EditorSection::Headers) - .set_offset(point(px(0.0), px(-120.0))); }) .unwrap(); diff --git a/crates/desktop/src/app/workspace.rs b/crates/desktop/src/app/workspace.rs index d382d7ca..1da1a13d 100644 --- a/crates/desktop/src/app/workspace.rs +++ b/crates/desktop/src/app/workspace.rs @@ -853,6 +853,13 @@ impl ProbeApp { .collect::>(); let result = reconcile(&clean_local, workspace, &BTreeMap::new()); if let ReconcileResult::Applied(reconciled) = result { + // Use Disk also discards rejected drafts that never reached + // the model. Detached requests are not replaced by disk. + if let Some(loaded) = &view.loaded_workspace { + for request in loaded.requests() { + view.request_editor.invalidate_editors(request.key()); + } + } view.apply_reconciled_workspace(*reconciled, cx); view.pending_environment_saves.clear(); view.failed_environment_saves.clear(); @@ -1047,6 +1054,19 @@ impl ProbeApp { let new_key = workspace.add_detached_request(request); remaps.insert(old_key, new_key); } + // A changed GraphQL body may select a different operation with identical + // displayed text. Drop its drafts and undo history before remapping. + for (previous_key, current_key) in &remaps { + if let Some((previous, current)) = old + .workspace() + .request(*previous_key) + .zip(workspace.workspace().request(*current_key)) + && (previous.kind.is_graphql() || current.kind.is_graphql()) + && previous.kind != current.kind + { + self.request_editor.invalidate_editors(*previous_key); + } + } self.detached_requests.remap(&remaps); self.persistence.reset(baselines); self.loaded_workspace = Some(workspace); diff --git a/crates/desktop/src/request_editor.rs b/crates/desktop/src/request_editor.rs index 77edd586..db43c5c6 100644 --- a/crates/desktop/src/request_editor.rs +++ b/crates/desktop/src/request_editor.rs @@ -324,6 +324,10 @@ impl RequestEditorState { .clone() } + pub(crate) fn invalidate_editors(&mut self, key: RequestKey) { + self.editors.get_mut().retain(|(owner, _), _| *owner != key); + } + pub(crate) fn scroll(&self, key: RequestKey, section: EditorSection) -> gpui_kit::ScrollHandle { self.scrolls .borrow_mut() @@ -364,7 +368,7 @@ impl RequestEditorState { } pub(crate) fn remove(&mut self, key: RequestKey) { - self.editors.get_mut().retain(|(owner, _), _| *owner != key); + self.invalidate_editors(key); self.scrolls.get_mut().retain(|(owner, _), _| *owner != key); self.sections.remove(&key); if self diff --git a/crates/desktop/src/response_viewer/tests.rs b/crates/desktop/src/response_viewer/tests.rs index e99f489c..df5b34df 100644 --- a/crates/desktop/src/response_viewer/tests.rs +++ b/crates/desktop/src/response_viewer/tests.rs @@ -700,57 +700,41 @@ fn results_for_replaced_or_closed_documents_are_ignored_after_a_reload() { #[test] fn inspector_scroll_is_per_request_survives_remaps_and_resets_with_response() { use gpui_kit::{point, px}; - use std::{collections::BTreeMap, rc::Rc}; + use std::collections::BTreeMap; let first = request_key(); let second = replacement_request_key(); let document = prepare_document(&response(b"body", "text/plain"), 1).0; let mut viewer = super::ResponseViewerState::default(); viewer.insert(first, document.clone()); viewer.insert(second, document.clone()); - let first_scroll = viewer.inspector_scroll(first).clone(); - first_scroll + let first_scroll = viewer + .inspector_scroll(first) .0 .borrow() .base_handle - .set_offset(point(px(0.0), px(-120.0))); - assert_eq!( - viewer - .inspector_scroll(second) - .0 - .borrow() - .base_handle - .offset() - .y, - px(0.0) - ); + .clone(); + let second_scroll = viewer + .inspector_scroll(second) + .0 + .borrow() + .base_handle + .clone(); + first_scroll.set_offset(point(px(0.0), px(-120.0))); + assert_eq!(second_scroll.offset().y, px(0.0)); viewer.remap_requests(&BTreeMap::from([(first, second)])); - assert!(Rc::ptr_eq( - &first_scroll.0, - &viewer.inspector_scroll(second).0 - )); - assert_eq!( - viewer - .inspector_scroll(second) - .0 - .borrow() - .base_handle - .offset() - .y, - px(-120.0) - ); + let remapped = viewer + .inspector_scroll(second) + .0 + .borrow() + .base_handle + .clone(); + assert_eq!(remapped.offset().y, px(-120.0)); viewer.insert(second, document); - assert_eq!( - viewer - .inspector_scroll(second) - .0 - .borrow() - .base_handle - .offset() - .y, - px(0.0) - ); - assert!(!Rc::ptr_eq( - &first_scroll.0, - &viewer.inspector_scroll(second).0 - )); + let replacement = viewer + .inspector_scroll(second) + .0 + .borrow() + .base_handle + .clone(); + assert_eq!(replacement.offset().y, px(0.0)); } From bd2544d8e32220fb8d6e35f2d975ecb40cc16aab Mon Sep 17 00:00:00 2001 From: Crizant Lai Date: Tue, 3 Nov 2026 13:49:38 +1000 Subject: [PATCH 3/4] fix(desktop): scope reload resets to protocol editors --- crates/desktop/src/app/tests/editor_state.rs | 172 ++++++++++++++++++- crates/desktop/src/app/workspace.rs | 9 +- crates/desktop/src/request_editor.rs | 20 +++ 3 files changed, 190 insertions(+), 11 deletions(-) diff --git a/crates/desktop/src/app/tests/editor_state.rs b/crates/desktop/src/app/tests/editor_state.rs index 5c54d75c..c28d99eb 100644 --- a/crates/desktop/src/app/tests/editor_state.rs +++ b/crates/desktop/src/app/tests/editor_state.rs @@ -126,7 +126,33 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo ), ] { let editor = select_editor(window, key, section, slot, cx); - editor.update(cx, |editor, cx| editor.set_selected_range(0..6, cx)); + // Exercise shared editor behavior once; other rows check their wiring. + let http_body = key == http && section == EditorSection::Body; + let original = editor.read_with(cx, |editor, _| editor.value()); + if http_body { + cx.simulate_input(window.into(), "edited"); + cx.simulate_keystrokes(window.into(), find_shortcut()); + cx.simulate_input(window.into(), "needle"); + cx.run_until_parked(); + editor.update(cx, |editor, cx| editor.next_search_match(cx)); + } + let selection = if http_body { 110..116 } else { 0..6 }; + editor.update(cx, |editor, cx| { + editor.set_selected_range(selection.clone(), cx) + }); + cx.run_until_parked(); + if http_body { + editor.update(cx, |editor, cx| { + editor.set_scroll_offset(point(px(0.0), px(-100.0)), cx) + }); + cx.run_until_parked(); + } + let (offset, match_index) = editor.read_with(cx, |editor, _| { + ( + editor.scroll_offset(), + editor.search_session().matcher.current_match_index(), + ) + }); // Unmount the section, then leave the request. Each editor must retain // its session through both transitions; restore it only once. window @@ -145,9 +171,33 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo assert_eq!(select_editor(window, key, section, slot, cx), editor); assert_eq!( editor.read_with(cx, |state, _| state.selected_range()), - 0..6, + selection, "{slot}" ); + if http_body { + cx.run_until_parked(); + editor.read_with(cx, |editor, _| { + assert!(offset.y < px(0.0)); + assert!(match_index > 0); + assert_eq!(editor.scroll_offset(), offset); + assert!(editor.search_session().is_active()); + assert_eq!(editor.search_session().query, "needle"); + assert_eq!( + editor.search_session().matcher.current_match_index(), + match_index + ); + }); + let mut visual = VisualTestContext::from_window(window.into(), cx); + assert!(visual.debug_bounds("editor-search-card").is_some()); + cx.simulate_keystrokes(window.into(), "escape"); + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx); + }) + .unwrap(); + cx.run_until_parked(); + assert_eq!(editor.read_with(cx, |editor, _| editor.value()), original); + } } let editor = select_editor(window, http, EditorSection::Body, "body-text", cx); let weak = editor.downgrade(); @@ -215,6 +265,10 @@ fn overview_editor_keeps_session_until_closed(cx: &mut TestAppContext) { fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mut TestAppContext) { let (window, [_, key, _]) = editor_workspace(cx); let fixture = bundled_fixture(); + let docs = select_editor(window, key, EditorSection::Docs, "request-description", cx); + cx.simulate_input(window.into(), "documentation"); + cx.run_until_parked(); + let docs_selection = docs.read_with(cx, |editor, _| editor.selected_range()); let mut editors = Vec::new(); for (section, slot) in [ (EditorSection::GraphqlQuery, "graphql-query"), @@ -245,16 +299,15 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu .update(cx, |view, _, cx| { let mut fresh = probe_opencollection::load_workspace(&fixture).unwrap(); let current = view.loaded_workspace.as_ref().unwrap(); - let mut kind = current + let mut request = current .workspace() .request(current.requests()[1].key()) .unwrap() - .kind .clone(); if changed && let RequestKind::Graphql { body: Some(GraphqlBody::Variants(variants)), - } = &mut kind + } = &mut request.kind { // The new operation has identical text and a duplicate title. if change == 1 { @@ -266,11 +319,19 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu } } let key = fresh.requests()[1].key(); - fresh.request_mut(key).unwrap().kind = kind; + *fresh.request_mut(key).unwrap() = request; view.apply_reconciled_workspace(reconciled_workspace(fresh), cx); key }) .unwrap(); + assert_eq!( + select_editor(window, key, EditorSection::Docs, "request-description", cx), + docs + ); + assert_eq!( + docs.read_with(cx, |editor, _| editor.selected_range()), + docs_selection + ); for (section, slot, previous) in &mut editors { let restored = select_editor(window, key, *section, slot, cx); assert_eq!(restored == *previous, !changed, "{slot}"); @@ -308,3 +369,102 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu } } } + +#[gpui_kit::test] +fn websocket_variant_reload_resets_message_undo_but_keeps_docs_and_composer( + cx: &mut TestAppContext, +) { + use probe_core::{ + WebSocketMessage, WebSocketMessageKind, WebSocketMessageSet, WebSocketMessageVariant, + }; + let (window, [key, ..]) = editor_workspace(cx); + let section = EditorSection::WebSocketMessage; + window + .update(cx, |view, _, _| { + let message = WebSocketMessage { + kind: WebSocketMessageKind::Text, + data: "message".into(), + }; + let loaded = view.loaded_workspace.as_mut().unwrap(); + loaded.request_mut(key).unwrap().kind = RequestKind::WebSocket { + message: Some(WebSocketMessageSet::Variants( + [true, false] + .map(|selected| WebSocketMessageVariant { + title: "Same title".into(), + selected, + message: message.clone(), + }) + .into(), + )), + }; + let (cancel, _) = oneshot::channel(); + view.websocket.begin(key, cancel); + let session = view.websocket.sessions.get_mut(&key).unwrap(); + session.state = crate::websocket::ConnectionState::Connected; + session.draft = "live draft".into(); + }) + .unwrap(); + let docs = select_editor(window, key, EditorSection::Docs, "request-docs", cx); + docs.update(cx, |editor, cx| editor.set_selected_range(0..6, cx)); + let composer = select_editor(window, key, section, "websocket-composer", cx); + let message = select_editor(window, key, section, "websocket-message", cx); + cx.simulate_input(window.into(), "edited"); + cx.run_until_parked(); + let expected = message.read_with(cx, |editor, _| editor.value()); + let key = window + .update(cx, |view, _, cx| { + let mut fresh = probe_opencollection::load_workspace(bundled_fixture()).unwrap(); + let loaded = view.loaded_workspace.as_ref().unwrap(); + let mut request = loaded.workspace().request(key).unwrap().clone(); + let RequestKind::WebSocket { + message: Some(WebSocketMessageSet::Variants(variants)), + } = &mut request.kind + else { + panic!("expected configured message variants"); + }; + // Switch variants without changing the displayed text or title. + variants[1].message = variants[0].message.clone(); + variants[0].selected = false; + variants[1].selected = true; + let key = fresh.requests()[0].key(); + *fresh.request_mut(key).unwrap() = request; + view.apply_reconciled_workspace(reconciled_workspace(fresh), cx); + key + }) + .unwrap(); + assert_eq!( + select_editor(window, key, EditorSection::Docs, "request-docs", cx), + docs + ); + assert_eq!( + docs.read_with(cx, |editor, _| editor.selected_range()), + 0..6 + ); + assert_eq!( + select_editor(window, key, section, "websocket-composer", cx), + composer + ); + assert_eq!( + composer.read_with(cx, |editor, _| editor.value()), + "live draft" + ); + let restored = select_editor(window, key, section, "websocket-message", cx); + assert_ne!(restored, message); + window + .update(cx, |_, window, cx| { + window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx) + }) + .unwrap(); + cx.run_until_parked(); + assert_eq!(restored.read_with(cx, |editor, _| editor.value()), expected); + window + .read_with(cx, |view, _| { + let loaded = view.loaded_workspace.as_ref().unwrap(); + let request = loaded.workspace().request(key).unwrap(); + assert_eq!( + request.selected_websocket_message().unwrap().unwrap().data, + expected.as_ref() + ); + }) + .unwrap(); +} diff --git a/crates/desktop/src/app/workspace.rs b/crates/desktop/src/app/workspace.rs index 1da1a13d..70589e76 100644 --- a/crates/desktop/src/app/workspace.rs +++ b/crates/desktop/src/app/workspace.rs @@ -1054,17 +1054,16 @@ impl ProbeApp { let new_key = workspace.add_detached_request(request); remaps.insert(old_key, new_key); } - // A changed GraphQL body may select a different operation with identical - // displayed text. Drop its drafts and undo history before remapping. + // Changed protocol bodies may select a different variant with identical + // displayed text. Drop only their editors before remapping. for (previous_key, current_key) in &remaps { if let Some((previous, current)) = old .workspace() .request(*previous_key) .zip(workspace.workspace().request(*current_key)) - && (previous.kind.is_graphql() || current.kind.is_graphql()) - && previous.kind != current.kind { - self.request_editor.invalidate_editors(*previous_key); + self.request_editor + .invalidate_changed_editors(*previous_key, previous, current); } } self.detached_requests.remap(&remaps); diff --git a/crates/desktop/src/request_editor.rs b/crates/desktop/src/request_editor.rs index db43c5c6..4d089039 100644 --- a/crates/desktop/src/request_editor.rs +++ b/crates/desktop/src/request_editor.rs @@ -328,6 +328,26 @@ impl RequestEditorState { self.editors.get_mut().retain(|(owner, _), _| *owner != key); } + pub(crate) fn invalidate_changed_editors( + &mut self, + key: RequestKey, + previous: &Request, + current: &Request, + ) { + if (previous.kind.is_graphql() || current.kind.is_graphql()) + && previous.kind != current.kind + { + for slot in ["graphql-query", "graphql-variables", "graphql-extensions"] { + self.editors.get_mut().remove(&(key, slot)); + } + } + if (previous.kind.is_websocket() || current.kind.is_websocket()) + && previous.kind != current.kind + { + self.editors.get_mut().remove(&(key, "websocket-message")); + } + } + pub(crate) fn scroll(&self, key: RequestKey, section: EditorSection) -> gpui_kit::ScrollHandle { self.scrolls .borrow_mut() From 584428cc4fee2d013ac2417dbb02b6fa4b448273 Mon Sep 17 00:00:00 2001 From: Crizant Lai Date: Tue, 3 Nov 2026 14:02:11 +1000 Subject: [PATCH 4/4] test(desktop): trim redundant editor retention regressions --- crates/desktop/src/app/tests/editor_state.rs | 40 +++++--------------- crates/desktop/src/app/tests/response.rs | 10 ----- crates/desktop/src/app/tests/workspace.rs | 22 ++++------- crates/desktop/src/response_viewer/tests.rs | 34 +++++------------ 4 files changed, 26 insertions(+), 80 deletions(-) diff --git a/crates/desktop/src/app/tests/editor_state.rs b/crates/desktop/src/app/tests/editor_state.rs index c28d99eb..8ca209eb 100644 --- a/crates/desktop/src/app/tests/editor_state.rs +++ b/crates/desktop/src/app/tests/editor_state.rs @@ -168,15 +168,15 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo }) .unwrap(); cx.run_until_parked(); - assert_eq!(select_editor(window, key, section, slot, cx), editor); + let restored = select_editor(window, key, section, slot, cx); assert_eq!( - editor.read_with(cx, |state, _| state.selected_range()), + restored.read_with(cx, |state, _| state.selected_range()), selection, "{slot}" ); if http_body { cx.run_until_parked(); - editor.read_with(cx, |editor, _| { + restored.read_with(cx, |editor, _| { assert!(offset.y < px(0.0)); assert!(match_index > 0); assert_eq!(editor.scroll_offset(), offset); @@ -196,7 +196,7 @@ fn request_editors_keep_sessions_across_sections_and_requests(cx: &mut TestAppCo }) .unwrap(); cx.run_until_parked(); - assert_eq!(editor.read_with(cx, |editor, _| editor.value()), original); + assert_eq!(restored.read_with(cx, |editor, _| editor.value()), original); } } let editor = select_editor(window, http, EditorSection::Body, "body-text", cx); @@ -293,8 +293,7 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu editors.push((section, slot, editor)); } let expected_query = editors[0].2.read_with(cx, |editor, _| editor.value()); - for change in 0..3 { - let changed = change != 0; + for changed in [false, true] { let key = window .update(cx, |view, _, cx| { let mut fresh = probe_opencollection::load_workspace(&fixture).unwrap(); @@ -310,13 +309,9 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu } = &mut request.kind { // The new operation has identical text and a duplicate title. - if change == 1 { - variants[1].body = variants[0].body.clone(); - variants[0].selected = false; - variants[1].selected = true; - } else { - variants[1].body.operation_name = Some("Changed".into()); - } + variants[1].body = variants[0].body.clone(); + variants[0].selected = false; + variants[1].selected = true; } let key = fresh.requests()[1].key(); *fresh.request_mut(key).unwrap() = request; @@ -332,10 +327,8 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu docs.read_with(cx, |editor, _| editor.selected_range()), docs_selection ); - for (section, slot, previous) in &mut editors { + for (section, slot, _) in &editors { let restored = select_editor(window, key, *section, slot, cx); - assert_eq!(restored == *previous, !changed, "{slot}"); - *previous = restored.clone(); if *section == EditorSection::GraphqlQuery { window .update(cx, |_, window, cx| { @@ -371,9 +364,7 @@ fn graphql_reload_keeps_unchanged_sessions_but_resets_changed_operations(cx: &mu } #[gpui_kit::test] -fn websocket_variant_reload_resets_message_undo_but_keeps_docs_and_composer( - cx: &mut TestAppContext, -) { +fn websocket_variant_reload_resets_message_undo_but_keeps_composer(cx: &mut TestAppContext) { use probe_core::{ WebSocketMessage, WebSocketMessageKind, WebSocketMessageSet, WebSocketMessageVariant, }; @@ -404,8 +395,6 @@ fn websocket_variant_reload_resets_message_undo_but_keeps_docs_and_composer( session.draft = "live draft".into(); }) .unwrap(); - let docs = select_editor(window, key, EditorSection::Docs, "request-docs", cx); - docs.update(cx, |editor, cx| editor.set_selected_range(0..6, cx)); let composer = select_editor(window, key, section, "websocket-composer", cx); let message = select_editor(window, key, section, "websocket-message", cx); cx.simulate_input(window.into(), "edited"); @@ -432,14 +421,6 @@ fn websocket_variant_reload_resets_message_undo_but_keeps_docs_and_composer( key }) .unwrap(); - assert_eq!( - select_editor(window, key, EditorSection::Docs, "request-docs", cx), - docs - ); - assert_eq!( - docs.read_with(cx, |editor, _| editor.selected_range()), - 0..6 - ); assert_eq!( select_editor(window, key, section, "websocket-composer", cx), composer @@ -449,7 +430,6 @@ fn websocket_variant_reload_resets_message_undo_but_keeps_docs_and_composer( "live draft" ); let restored = select_editor(window, key, section, "websocket-message", cx); - assert_ne!(restored, message); window .update(cx, |_, window, cx| { window.dispatch_action(Box::new(gpui_kit::base::input::Undo), cx) diff --git a/crates/desktop/src/app/tests/response.rs b/crates/desktop/src/app/tests/response.rs index 6294400e..5932d3c0 100644 --- a/crates/desktop/src/app/tests/response.rs +++ b/crates/desktop/src/app/tests/response.rs @@ -482,11 +482,6 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont .expect("test window should remain open"); cx.simulate_keystrokes(window.into(), "o k"); cx.run_until_parked(); - { - let mut visual = VisualTestContext::from_window(window.into(), cx); - assert!(visual.debug_bounds("editor-search-card").is_some()); - assert!(visual.debug_bounds("response-body").is_some()); - } let editor = window .update(cx, |view, _, cx| { let editor = view @@ -523,17 +518,12 @@ fn completed_response_renders_pretty_raw_headers_and_search(cx: &mut TestAppCont }) .unwrap(); cx.run_until_parked(); - { - let mut visual = VisualTestContext::from_window(window.into(), cx); - assert!(visual.debug_bounds("editor-search-card").is_some()); - } window .update(cx, |view, _, cx| { let restored = view .response_viewer .editor(request_key, ResponseViewerTab::Pretty) .editor(cx); - assert_eq!(restored, editor); assert_eq!(restored.read(cx).scroll_offset(), offset); assert_eq!(restored.read(cx).search_session().query, "ok"); }) diff --git a/crates/desktop/src/app/tests/workspace.rs b/crates/desktop/src/app/tests/workspace.rs index c197527a..ca8556f4 100644 --- a/crates/desktop/src/app/tests/workspace.rs +++ b/crates/desktop/src/app/tests/workspace.rs @@ -394,9 +394,7 @@ fn new_request_tabs_are_in_memory_and_editable(cx: &mut TestAppContext) { #[gpui_kit::test] fn request_editor_lists_scroll_when_the_pointer_is_over_a_field(cx: &mut TestAppContext) { cx.update(Theme::init); - let window = cx.open_window(size(px(1180.0), px(780.0)), |window, cx| { - ProbeApp::new(window, cx) - }); + let window = cx.open_window(size(px(1180.0), px(780.0)), ProbeApp::new); let fixture = bundled_fixture().canonicalize().unwrap(); let workspace = probe_opencollection::load_workspace(&fixture).unwrap(); window @@ -3184,9 +3182,7 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( cx: &mut TestAppContext, ) { cx.update(Theme::init); - let window = cx.open_window(size(px(900.0), px(640.0)), |window, cx| { - ProbeApp::new(window, cx) - }); + let window = cx.open_window(size(px(900.0), px(640.0)), ProbeApp::new); let fixture = writable_bundled_fixture("filesystem-reload"); // Keep the GraphQL body unchanged on disk, so Use Disk must reset a // rejected variables draft even though its model value never changed. @@ -3217,14 +3213,13 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( .unwrap(); cx.run_until_parked(); - let variables = window + window .update(cx, |view, window, cx| { let editor = view .request_editor .editor(key, "graphql-variables") .editor(cx); editor.update(cx, |editor, cx| editor.focus(window, cx)); - editor }) .unwrap(); cx.simulate_input(window.into(), "invalid"); @@ -3262,12 +3257,10 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( Some(ApplicationDialog::FilesystemConflict { .. }) )); let active = view.shell.active_tab().unwrap(); - assert_eq!( - view.request_editor - .editor(active, "graphql-variables") - .editor(cx), - variables - ); + let variables = view + .request_editor + .editor(active, "graphql-variables") + .editor(cx); assert_eq!(variables.read(cx).value(), "invalid"); view.handle_application_dialog_action(ApplicationDialogAction::UseDisk, window, cx); }) @@ -3286,7 +3279,6 @@ fn filesystem_reload_merges_against_disk_baselines_and_use_disk_discards_edits( .request_editor .editor(key, "graphql-variables") .editor(cx); - assert_ne!(restored, variables); assert_eq!(restored.read(cx).value(), ""); }) .unwrap(); diff --git a/crates/desktop/src/response_viewer/tests.rs b/crates/desktop/src/response_viewer/tests.rs index df5b34df..d4031043 100644 --- a/crates/desktop/src/response_viewer/tests.rs +++ b/crates/desktop/src/response_viewer/tests.rs @@ -707,34 +707,18 @@ fn inspector_scroll_is_per_request_survives_remaps_and_resets_with_response() { let mut viewer = super::ResponseViewerState::default(); viewer.insert(first, document.clone()); viewer.insert(second, document.clone()); - let first_scroll = viewer - .inspector_scroll(first) + let first_scroll = viewer.inspector_scroll(first); + let second_scroll = viewer.inspector_scroll(second); + first_scroll .0 .borrow() .base_handle - .clone(); - let second_scroll = viewer - .inspector_scroll(second) - .0 - .borrow() - .base_handle - .clone(); - first_scroll.set_offset(point(px(0.0), px(-120.0))); - assert_eq!(second_scroll.offset().y, px(0.0)); + .set_offset(point(px(0.0), px(-120.0))); + assert_eq!(second_scroll.0.borrow().base_handle.offset().y, px(0.0)); viewer.remap_requests(&BTreeMap::from([(first, second)])); - let remapped = viewer - .inspector_scroll(second) - .0 - .borrow() - .base_handle - .clone(); - assert_eq!(remapped.offset().y, px(-120.0)); + let remapped = viewer.inspector_scroll(second); + assert_eq!(remapped.0.borrow().base_handle.offset().y, px(-120.0)); viewer.insert(second, document); - let replacement = viewer - .inspector_scroll(second) - .0 - .borrow() - .base_handle - .clone(); - assert_eq!(replacement.offset().y, px(0.0)); + let replacement = viewer.inspector_scroll(second); + assert_eq!(replacement.0.borrow().base_handle.offset().y, px(0.0)); }