factor write command tests to own module

helix-term/tests/integration.rs

@@ -23,5 +23,4 @@ mod test {
     mod movement;
     mod prompt;
     mod splits;
-    mod write;
 }

helix-term/tests/test/commands.rs

@@ -1,99 +1,8 @@
-use std::ops::RangeInclusive;
-
-use helix_core::diagnostic::Severity;
 use helix_term::application::Application;
 
 use super::*;
 
-#[tokio::test(flavor = "multi_thread")]
-async fn test_write_quit_fail() -> anyhow::Result<()> {
-    let file = helpers::new_readonly_tempfile()?;
-    let mut app = helpers::AppBuilder::new()
-        .with_file(file.path(), None)
-        .build()?;
-
-    test_key_sequence(
-        &mut app,
-        Some("ihello<esc>:wq<ret>"),
-        Some(&|app| {
-            let mut docs: Vec<_> = app.editor.documents().collect();
-            assert_eq!(1, docs.len());
-
-            let doc = docs.pop().unwrap();
-            assert_eq!(Some(file.path()), doc.path().map(PathBuf::as_path));
-            assert_eq!(&Severity::Error, app.editor.get_status().unwrap().1);
-        }),
-        false,
-    )
-    .await?;
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn test_buffer_close_concurrent() -> anyhow::Result<()> {
-    test_key_sequences(
-        &mut helpers::AppBuilder::new().build()?,
-        vec![
-            (
-                None,
-                Some(&|app| {
-                    assert_eq!(1, app.editor.documents().count());
-                    assert!(!app.editor.is_err());
-                }),
-            ),
-            (
-                Some("ihello<esc>:new<ret>"),
-                Some(&|app| {
-                    assert_eq!(2, app.editor.documents().count());
-                    assert!(!app.editor.is_err());
-                }),
-            ),
-            (
-                Some(":buffer<minus>close<ret>"),
-                Some(&|app| {
-                    assert_eq!(1, app.editor.documents().count());
-                    assert!(!app.editor.is_err());
-                }),
-            ),
-        ],
-        false,
-    )
-    .await?;
-
-    // verify if writes are queued up, it finishes them before closing the buffer
-    let mut file = tempfile::NamedTempFile::new()?;
-    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);
-    }
-
-    command.push_str(":buffer<minus>close<ret>");
-
-    let mut app = helpers::AppBuilder::new()
-        .with_file(file.path(), None)
-        .build()?;
-
-    test_key_sequence(
-        &mut app,
-        Some(&command),
-        Some(&|app| {
-            assert!(!app.editor.is_err(), "error: {:?}", app.editor.get_status());
-
-            let doc = app.editor.document_by_path(file.path());
-            assert!(doc.is_none(), "found doc: {:?}", doc);
-        }),
-        false,
-    )
-    .await?;
-
-    helpers::assert_file_has_content(file.as_file_mut(), &RANGE.end().to_string())?;
-
-    Ok(())
-}
+mod write;
 
 #[tokio::test(flavor = "multi_thread")]
 async fn test_selection_duplication() -> anyhow::Result<()> {

helix-term/tests/test/commands/write.rs

@@ -1,5 +1,5 @@
 use std::{
-    io::{Read, Seek, SeekFrom, Write},
+    io::{Read, Seek, Write},
     ops::RangeInclusive,
 };
 
@@ -8,6 +8,96 @@ use helix_view::doc;
 
 use super::*;
 
+#[tokio::test(flavor = "multi_thread")]
+async fn test_write_quit_fail() -> anyhow::Result<()> {
+    let file = helpers::new_readonly_tempfile()?;
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .build()?;
+
+    test_key_sequence(
+        &mut app,
+        Some("ihello<esc>:wq<ret>"),
+        Some(&|app| {
+            let mut docs: Vec<_> = app.editor.documents().collect();
+            assert_eq!(1, docs.len());
+
+            let doc = docs.pop().unwrap();
+            assert_eq!(Some(file.path()), doc.path().map(PathBuf::as_path));
+            assert_eq!(&Severity::Error, app.editor.get_status().unwrap().1);
+        }),
+        false,
+    )
+    .await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_buffer_close_concurrent() -> anyhow::Result<()> {
+    test_key_sequences(
+        &mut helpers::AppBuilder::new().build()?,
+        vec![
+            (
+                None,
+                Some(&|app| {
+                    assert_eq!(1, app.editor.documents().count());
+                    assert!(!app.editor.is_err());
+                }),
+            ),
+            (
+                Some("ihello<esc>:new<ret>"),
+                Some(&|app| {
+                    assert_eq!(2, app.editor.documents().count());
+                    assert!(!app.editor.is_err());
+                }),
+            ),
+            (
+                Some(":buffer<minus>close<ret>"),
+                Some(&|app| {
+                    assert_eq!(1, app.editor.documents().count());
+                    assert!(!app.editor.is_err());
+                }),
+            ),
+        ],
+        false,
+    )
+    .await?;
+
+    // verify if writes are queued up, it finishes them before closing the buffer
+    let mut file = tempfile::NamedTempFile::new()?;
+    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);
+    }
+
+    command.push_str(":buffer<minus>close<ret>");
+
+    let mut app = helpers::AppBuilder::new()
+        .with_file(file.path(), None)
+        .build()?;
+
+    test_key_sequence(
+        &mut app,
+        Some(&command),
+        Some(&|app| {
+            assert!(!app.editor.is_err(), "error: {:?}", app.editor.get_status());
+
+            let doc = app.editor.document_by_path(file.path());
+            assert!(doc.is_none(), "found doc: {:?}", doc);
+        }),
+        false,
+    )
+    .await?;
+
+    helpers::assert_file_has_content(file.as_file_mut(), &RANGE.end().to_string())?;
+
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn test_write() -> anyhow::Result<()> {
     let mut file = tempfile::NamedTempFile::new()?;
@@ -57,7 +147,7 @@ async fn test_overwrite_protection() -> anyhow::Result<()> {
     file.as_file_mut().flush()?;
     file.as_file_mut().sync_all()?;
 
-    file.seek(SeekFrom::Start(0))?;
+    file.rewind()?;
     let mut file_content = String::new();
     file.as_file_mut().read_to_string(&mut file_content)?;