Merge pull request #2267 from dead10ck/fix-write-fail

Write path fixes

1 files changed, 135 insertions, 17 deletions

diff --git a/helix-term/tests/test/write.rs b/helix-term/tests/test/write.rs
index 8869d881..6aa51a31 100644
--- a/helix-term/tests/test/write.rs
+++ b/helix-term/tests/test/write.rs
@@ -4,7 +4,6 @@ use std::{
 };
 
 use helix_core::diagnostic::Severity;
-use helix_term::application::Application;
 use helix_view::doc;
 
 use super::*;
@@ -12,9 +11,12 @@ use super::*;
 #[tokio::test]
 async fn test_write() -> anyhow::Result<()> {
     let mut file = tempfile::NamedTempFile::new()?;
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .build()?;
 
     test_key_sequence(
-        &mut helpers::app_with_file(file.path())?,
+        &mut app,
         Some("ithe gostak distims the doshes<ret><esc>:w<ret>"),
         None,
         false,
@@ -35,12 +37,15 @@ async fn test_write() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[tokio::test(flavor = "multi_thread")]
 async fn test_write_quit() -> anyhow::Result<()> {
     let mut file = tempfile::NamedTempFile::new()?;
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .build()?;
 
     test_key_sequence(
-        &mut helpers::app_with_file(file.path())?,
+        &mut app,
         Some("ithe gostak distims the doshes<ret><esc>:wq<ret>"),
         None,
         true,
@@ -61,25 +66,21 @@ async fn test_write_quit() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-#[ignore]
+#[tokio::test(flavor = "multi_thread")]
 async fn test_write_concurrent() -> anyhow::Result<()> {
     let mut file = tempfile::NamedTempFile::new()?;
     let mut command = String::new();
     const RANGE: RangeInclusive<i32> = 1..=5000;
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .build()?;
 
     for i in RANGE {
         let cmd = format!("%c{}<esc>:w<ret>", i);
         command.push_str(&cmd);
     }
 
-    test_key_sequence(
-        &mut helpers::app_with_file(file.path())?,
-        Some(&command),
-        None,
-        false,
-    )
-    .await?;
+    test_key_sequence(&mut app, Some(&command), None, false).await?;
 
     file.as_file_mut().flush()?;
     file.as_file_mut().sync_all()?;
@@ -92,12 +93,14 @@ async fn test_write_concurrent() -> anyhow::Result<()> {
 }
 
 #[tokio::test]
-#[ignore]
 async fn test_write_fail_mod_flag() -> anyhow::Result<()> {
     let file = helpers::new_readonly_tempfile()?;
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .build()?;
 
     test_key_sequences(
-        &mut helpers::app_with_file(file.path())?,
+        &mut app,
         vec![
             (
                 None,
@@ -131,12 +134,127 @@ async fn test_write_fail_mod_flag() -> anyhow::Result<()> {
 }
 
 #[tokio::test]
-#[ignore]
+async fn test_write_scratch_to_new_path() -> anyhow::Result<()> {
+    let mut file = tempfile::NamedTempFile::new()?;
+
+    test_key_sequence(
+        &mut AppBuilder::new().build()?,
+        Some(format!("ihello<esc>:w {}<ret>", file.path().to_string_lossy()).as_ref()),
+        Some(&|app| {
+            assert!(!app.editor.is_err());
+
+            let mut docs: Vec<_> = app.editor.documents().collect();
+            assert_eq!(1, docs.len());
+
+            let doc = docs.pop().unwrap();
+            assert_eq!(Some(&file.path().to_path_buf()), doc.path());
+        }),
+        false,
+    )
+    .await?;
+
+    helpers::assert_file_has_content(file.as_file_mut(), &helpers::platform_line("hello"))?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_write_scratch_no_path_fails() -> anyhow::Result<()> {
+    helpers::test_key_sequence_with_input_text(
+        None,
+        ("#[\n|]#", "ihello<esc>:w<ret>", "hello#[\n|]#"),
+        &|app| {
+            assert!(app.editor.is_err());
+
+            let mut docs: Vec<_> = app.editor.documents().collect();
+            assert_eq!(1, docs.len());
+
+            let doc = docs.pop().unwrap();
+            assert_eq!(None, doc.path());
+        },
+        false,
+    )
+    .await?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_write_auto_format_fails_still_writes() -> anyhow::Result<()> {
+    let mut file = tempfile::Builder::new().suffix(".rs").tempfile()?;
+
+    let lang_conf = indoc! {r#"
+            [[language]]
+            name = "rust"
+            formatter = { command = "bash", args = [ "-c", "exit 1" ] }
+        "#};
+
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .with_input_text("#[l|]#et foo = 0;\n")
+        .with_lang_config(helpers::test_syntax_conf(Some(lang_conf.into())))
+        .build()?;
+
+    test_key_sequences(&mut app, vec![(Some(":w<ret>"), None)], false).await?;
+
+    // file still saves
+    helpers::assert_file_has_content(file.as_file_mut(), "let foo = 0;\n")?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_write_new_path() -> anyhow::Result<()> {
+    let mut file1 = tempfile::NamedTempFile::new().unwrap();
+    let mut file2 = tempfile::NamedTempFile::new().unwrap();
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file1.path(), None)
+        .build()?;
+
+    test_key_sequences(
+        &mut app,
+        vec![
+            (
+                Some("ii can eat glass, it will not hurt me<ret><esc>:w<ret>"),
+                Some(&|app| {
+                    let doc = doc!(app.editor);
+                    assert!(!app.editor.is_err());
+                    assert_eq!(file1.path(), doc.path().unwrap());
+                }),
+            ),
+            (
+                Some(&format!(":w {}<ret>", file2.path().to_string_lossy())),
+                Some(&|app| {
+                    let doc = doc!(app.editor);
+                    assert!(!app.editor.is_err());
+                    assert_eq!(file2.path(), doc.path().unwrap());
+                    assert!(app.editor.document_by_path(file1.path()).is_none());
+                }),
+            ),
+        ],
+        false,
+    )
+    .await?;
+
+    helpers::assert_file_has_content(
+        file1.as_file_mut(),
+        &helpers::platform_line("i can eat glass, it will not hurt me\n"),
+    )?;
+
+    helpers::assert_file_has_content(
+        file2.as_file_mut(),
+        &helpers::platform_line("i can eat glass, it will not hurt me\n"),
+    )?;
+
+    Ok(())
+}
+
+#[tokio::test]
 async fn test_write_fail_new_path() -> anyhow::Result<()> {
     let file = helpers::new_readonly_tempfile()?;
 
     test_key_sequences(
-        &mut Application::new(Args::default(), Config::default())?,
+        &mut AppBuilder::new().build()?,
         vec![
             (
                 None,