1use std::ops::{Deref, DerefMut};
  2
  3use editor::test::{AssertionContextManager, EditorTestContext};
  4use gpui::{json::json, AppContext, ViewHandle};
  5use project::Project;
  6use search::{BufferSearchBar, ProjectSearchBar};
  7use workspace::{pane, AppState, WorkspaceHandle};
  8
  9use crate::{state::Operator, *};
 10
 11use super::VimBindingTestContext;
 12
 13pub struct VimTestContext<'a> {
 14    cx: EditorTestContext<'a>,
 15    workspace: ViewHandle<Workspace>,
 16}
 17
 18impl<'a> VimTestContext<'a> {
 19    pub async fn new(cx: &'a mut gpui::TestAppContext, enabled: bool) -> VimTestContext<'a> {
 20        cx.update(|cx| {
 21            editor::init(cx);
 22            pane::init(cx);
 23            search::init(cx);
 24            crate::init(cx);
 25
 26            settings::KeymapFileContent::load("keymaps/vim.json", cx).unwrap();
 27        });
 28
 29        let params = cx.update(AppState::test);
 30        let project = Project::test(params.fs.clone(), [], cx).await;
 31
 32        cx.update(|cx| {
 33            cx.update_global(|settings: &mut Settings, _| {
 34                settings.vim_mode = enabled;
 35            });
 36        });
 37
 38        params
 39            .fs
 40            .as_fake()
 41            .insert_tree("/root", json!({ "dir": { "test.txt": "" } }))
 42            .await;
 43
 44        let (window_id, workspace) =
 45            cx.add_window(|cx| Workspace::new(project.clone(), |_, _| unimplemented!(), cx));
 46
 47        // Setup search toolbars
 48        workspace.update(cx, |workspace, cx| {
 49            workspace.active_pane().update(cx, |pane, cx| {
 50                pane.toolbar().update(cx, |toolbar, cx| {
 51                    let buffer_search_bar = cx.add_view(BufferSearchBar::new);
 52                    toolbar.add_item(buffer_search_bar, cx);
 53                    let project_search_bar = cx.add_view(|_| ProjectSearchBar::new());
 54                    toolbar.add_item(project_search_bar, cx);
 55                })
 56            });
 57        });
 58
 59        project
 60            .update(cx, |project, cx| {
 61                project.find_or_create_local_worktree("/root", true, cx)
 62            })
 63            .await
 64            .unwrap();
 65        cx.read(|cx| workspace.read(cx).worktree_scans_complete(cx))
 66            .await;
 67
 68        let file = cx.read(|cx| workspace.file_project_paths(cx)[0].clone());
 69        let item = workspace
 70            .update(cx, |workspace, cx| workspace.open_path(file, true, cx))
 71            .await
 72            .expect("Could not open test file");
 73
 74        let editor = cx.update(|cx| {
 75            item.act_as::<Editor>(cx)
 76                .expect("Opened test file wasn't an editor")
 77        });
 78        editor.update(cx, |_, cx| cx.focus_self());
 79
 80        Self {
 81            cx: EditorTestContext {
 82                cx,
 83                window_id,
 84                editor,
 85                assertion_context: AssertionContextManager::new(),
 86            },
 87            workspace,
 88        }
 89    }
 90
 91    pub fn workspace<F, T>(&mut self, read: F) -> T
 92    where
 93        F: FnOnce(&Workspace, &AppContext) -> T,
 94    {
 95        self.workspace.read_with(self.cx.cx, read)
 96    }
 97
 98    pub fn enable_vim(&mut self) {
 99        self.cx.update(|cx| {
100            cx.update_global(|settings: &mut Settings, _| {
101                settings.vim_mode = true;
102            });
103        })
104    }
105
106    pub fn disable_vim(&mut self) {
107        self.cx.update(|cx| {
108            cx.update_global(|settings: &mut Settings, _| {
109                settings.vim_mode = false;
110            });
111        })
112    }
113
114    pub fn mode(&mut self) -> Mode {
115        self.cx.read(|cx| cx.global::<Vim>().state.mode)
116    }
117
118    pub fn active_operator(&mut self) -> Option<Operator> {
119        self.cx
120            .read(|cx| cx.global::<Vim>().state.operator_stack.last().copied())
121    }
122
123    pub fn set_state(&mut self, text: &str, mode: Mode) {
124        self.cx.update(|cx| {
125            Vim::update(cx, |vim, cx| {
126                vim.switch_mode(mode, false, cx);
127            })
128        });
129        self.cx.set_state(text);
130    }
131
132    pub fn assert_state(&mut self, text: &str, mode: Mode) {
133        self.assert_editor_state(text);
134        assert_eq!(self.mode(), mode);
135    }
136
137    pub fn assert_binding<const COUNT: usize>(
138        &mut self,
139        keystrokes: [&str; COUNT],
140        initial_state: &str,
141        initial_mode: Mode,
142        state_after: &str,
143        mode_after: Mode,
144    ) {
145        self.set_state(initial_state, initial_mode);
146        self.cx.simulate_keystrokes(keystrokes);
147        self.cx.assert_editor_state(state_after);
148        assert_eq!(self.mode(), mode_after);
149        assert_eq!(self.active_operator(), None);
150    }
151
152    pub fn binding<const COUNT: usize>(
153        mut self,
154        keystrokes: [&'static str; COUNT],
155    ) -> VimBindingTestContext<'a, COUNT> {
156        let mode = self.mode();
157        VimBindingTestContext::new(keystrokes, mode, mode, self)
158    }
159}
160
161impl<'a> Deref for VimTestContext<'a> {
162    type Target = EditorTestContext<'a>;
163
164    fn deref(&self) -> &Self::Target {
165        &self.cx
166    }
167}
168
169impl<'a> DerefMut for VimTestContext<'a> {
170    fn deref_mut(&mut self) -> &mut Self::Target {
171        &mut self.cx
172    }
173}