use main application event loop

Use the Application's main event loop to allow LSP, file writes, etc

5 files changed, 136 insertions, 30 deletions

diff --git a/helix-term/tests/integration/auto_indent.rs b/helix-term/tests/integration/auto_indent.rs
index 18138cca..74d1ac58 100644
--- a/helix-term/tests/integration/auto_indent.rs
+++ b/helix-term/tests/integration/auto_indent.rs
@@ -18,7 +18,8 @@ async fn auto_indent_c() -> anyhow::Result<()> {
                 }
             "},
         ),
-    )?;
+    )
+    .await?;
 
     Ok(())
 }
diff --git a/helix-term/tests/integration/auto_pairs.rs b/helix-term/tests/integration/auto_pairs.rs
index 4da44d45..52fee55e 100644
--- a/helix-term/tests/integration/auto_pairs.rs
+++ b/helix-term/tests/integration/auto_pairs.rs
@@ -6,7 +6,8 @@ async fn auto_pairs_basic() -> anyhow::Result<()> {
         Args::default(),
         Config::default(),
         ("#[\n|]#", "i(<esc>", "(#[|)]#\n"),
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
@@ -18,7 +19,8 @@ async fn auto_pairs_basic() -> anyhow::Result<()> {
             ..Default::default()
         },
         ("#[\n|]#", "i(<esc>", "(#[|\n]#"),
-    )?;
+    )
+    .await?;
 
     Ok(())
 }
diff --git a/helix-term/tests/integration/helpers.rs b/helix-term/tests/integration/helpers.rs
index 5a853ad1..df662f07 100644
--- a/helix-term/tests/integration/helpers.rs
+++ b/helix-term/tests/integration/helpers.rs
@@ -1,9 +1,12 @@
-use std::io::Write;
+use std::{io::Write, time::Duration};
 
+use anyhow::bail;
 use crossterm::event::{Event, KeyEvent};
 use helix_core::{test, Selection, Transaction};
 use helix_term::{application::Application, args::Args, config::Config};
 use helix_view::{doc, input::parse_macro};
+use tokio::time::timeout;
+use tokio_stream::wrappers::UnboundedReceiverStream;
 
 #[derive(Clone, Debug)]
 pub struct TestCase {
@@ -29,10 +32,44 @@ impl<S: Into<String>> From<(S, S, S)> for TestCase {
     }
 }
 
-pub fn test_key_sequence<T: Into<TestCase>>(
+pub async fn test_key_sequence(
+    app: &mut Application,
+    in_keys: &str,
+    test_fn: Option<&dyn Fn(&Application)>,
+) -> anyhow::Result<()> {
+    let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
+
+    for key_event in parse_macro(&in_keys)?.into_iter() {
+        tx.send(Ok(Event::Key(KeyEvent::from(key_event))))?;
+    }
+
+    let mut rx_stream = UnboundedReceiverStream::new(rx);
+    let event_loop = app.event_loop(&mut rx_stream);
+    let result = timeout(Duration::from_millis(500), event_loop).await;
+
+    if result.is_ok() {
+        bail!("application exited before test function could run");
+    }
+
+    if let Some(test) = test_fn {
+        test(app);
+    };
+
+    for key_event in parse_macro("<esc>:q!<ret>")?.into_iter() {
+        tx.send(Ok(Event::Key(KeyEvent::from(key_event))))?;
+    }
+
+    let event_loop = app.event_loop(&mut rx_stream);
+    timeout(Duration::from_millis(5000), event_loop).await?;
+    app.close().await?;
+
+    Ok(())
+}
+
+pub async fn test_key_sequence_with_input_text<T: Into<TestCase>>(
     app: Option<Application>,
     test_case: T,
-    test_fn: &dyn Fn(&mut Application),
+    test_fn: &dyn Fn(&Application),
 ) -> anyhow::Result<()> {
     let test_case = test_case.into();
     let mut app =
@@ -50,23 +87,13 @@ pub fn test_key_sequence<T: Into<TestCase>>(
         view.id,
     );
 
-    let input_keys = parse_macro(&test_case.in_keys)?
-        .into_iter()
-        .map(|key_event| Event::Key(KeyEvent::from(key_event)));
-
-    for key in input_keys {
-        app.handle_terminal_events(Ok(key));
-    }
-
-    test_fn(&mut app);
-
-    Ok(())
+    test_key_sequence(&mut app, &test_case.in_keys, Some(test_fn)).await
 }
 
 /// Use this for very simple test cases where there is one input
 /// document, selection, and sequence of key presses, and you just
 /// want to verify the resulting document and selection.
-pub fn test_key_sequence_text_result<T: Into<TestCase>>(
+pub async fn test_key_sequence_text_result<T: Into<TestCase>>(
     args: Args,
     config: Config,
     test_case: T,
@@ -74,7 +101,7 @@ pub fn test_key_sequence_text_result<T: Into<TestCase>>(
     let test_case = test_case.into();
     let app = Application::new(args, config).unwrap();
 
-    test_key_sequence(Some(app), test_case.clone(), &|app| {
+    test_key_sequence_with_input_text(Some(app), test_case.clone(), &|app| {
         let doc = doc!(app.editor);
         assert_eq!(&test_case.out_text, doc.text());
 
@@ -83,9 +110,8 @@ pub fn test_key_sequence_text_result<T: Into<TestCase>>(
 
         let sel = selections.pop().unwrap();
         assert_eq!(test_case.out_selection, sel);
-    })?;
-
-    Ok(())
+    })
+    .await
 }
 
 pub fn temp_file_with_contents<S: AsRef<str>>(content: S) -> tempfile::NamedTempFile {
diff --git a/helix-term/tests/integration/movement.rs b/helix-term/tests/integration/movement.rs
index fc2583c1..cac10852 100644
--- a/helix-term/tests/integration/movement.rs
+++ b/helix-term/tests/integration/movement.rs
@@ -14,25 +14,29 @@ async fn insert_mode_cursor_position() -> anyhow::Result<()> {
             out_text: String::new(),
             out_selection: Selection::single(0, 0),
         },
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
         Config::default(),
         ("#[\n|]#", "i", "#[|\n]#"),
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
         Config::default(),
         ("#[\n|]#", "i<esc>", "#[|\n]#"),
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
         Config::default(),
         ("#[\n|]#", "i<esc>i", "#[|\n]#"),
-    )?;
+    )
+    .await?;
 
     Ok(())
 }
@@ -44,7 +48,8 @@ async fn insert_to_normal_mode_cursor_position() -> anyhow::Result<()> {
         Args::default(),
         Config::default(),
         ("#[f|]#oo\n", "vll<A-;><esc>", "#[|foo]#\n"),
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
@@ -60,7 +65,8 @@ async fn insert_to_normal_mode_cursor_position() -> anyhow::Result<()> {
                 #(|bar)#"
             },
         ),
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
@@ -76,7 +82,8 @@ async fn insert_to_normal_mode_cursor_position() -> anyhow::Result<()> {
                 #(ba|)#r"
             },
         ),
-    )?;
+    )
+    .await?;
 
     test_key_sequence_text_result(
         Args::default(),
@@ -92,7 +99,8 @@ async fn insert_to_normal_mode_cursor_position() -> anyhow::Result<()> {
                 #(b|)#ar"
             },
         ),
-    )?;
+    )
+    .await?;
 
     Ok(())
 }
diff --git a/helix-term/tests/integration/write.rs b/helix-term/tests/integration/write.rs
new file mode 100644
index 00000000..47e56288
--- /dev/null
+++ b/helix-term/tests/integration/write.rs
@@ -0,0 +1,69 @@
+use std::{
+    io::{Read, Write},
+    ops::RangeInclusive,
+};
+
+use helix_term::application::Application;
+
+use super::*;
+
+#[tokio::test]
+async fn test_write() -> anyhow::Result<()> {
+    let mut file = tempfile::NamedTempFile::new().unwrap();
+
+    test_key_sequence(
+        &mut Application::new(
+            Args {
+                files: vec![(file.path().to_path_buf(), Position::default())],
+                ..Default::default()
+            },
+            Config::default(),
+        )?,
+        "ii can eat glass, it will not hurt me<ret><esc>:w<ret>",
+        None,
+    )
+    .await?;
+
+    file.as_file_mut().flush()?;
+    file.as_file_mut().sync_all()?;
+
+    let mut file_content = String::new();
+    file.as_file_mut().read_to_string(&mut file_content)?;
+    assert_eq!("i can eat glass, it will not hurt me\n", file_content);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_write_concurrent() -> anyhow::Result<()> {
+    let mut file = tempfile::NamedTempFile::new().unwrap();
+    let mut command = String::new();
+    const RANGE: RangeInclusive<i32> = 1..=1000;
+
+    for i in RANGE {
+        let cmd = format!("%c{}<esc>:w<ret>", i);
+        command.push_str(&cmd);
+    }
+
+    test_key_sequence(
+        &mut Application::new(
+            Args {
+                files: vec![(file.path().to_path_buf(), Position::default())],
+                ..Default::default()
+            },
+            Config::default(),
+        )?,
+        &command,
+        None,
+    )
+    .await?;
+
+    file.as_file_mut().flush()?;
+    file.as_file_mut().sync_all()?;
+
+    let mut file_content = String::new();
+    file.as_file_mut().read_to_string(&mut file_content)?;
+    assert_eq!(RANGE.end().to_string(), file_content);
+
+    Ok(())
+}