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/write.rs → 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)?;