git.iko.soy/helix
on master help sign in
factor write command tests to own module
8c5ec95Skyler Hawthorne
helix-term/tests/integration.rs−1
compare with master
unifiedsplit
@@ -23,5 +23,4 @@ mod test {
23 mod movement;
23 mod movement;
24 mod prompt;
24 mod prompt;
25 mod splits;
25 mod splits;
26− mod write;
27}
26}
helix-term/tests/test/commands.rs+1−92
@@ -1,99 +1,8 @@
1−use std::ops::RangeInclusive;
2−
3−use helix_core::diagnostic::Severity;
4use helix_term::application::Application;
1use helix_term::application::Application;
5
2
6use super::*;
3use super::*;
7
4
8−#[tokio::test(flavor = "multi_thread")]
5+mod write;
9−async fn test_write_quit_fail() -> anyhow::Result<()> {
10− let file = helpers::new_readonly_tempfile()?;
11− let mut app = helpers::AppBuilder::new()
12− .with_file(file.path(), None)
13− .build()?;
14−
15− test_key_sequence(
16− &mut app,
17− Some("ihello<esc>:wq<ret>"),
18− Some(&|app| {
19− let mut docs: Vec<_> = app.editor.documents().collect();
20− assert_eq!(1, docs.len());
21−
22− let doc = docs.pop().unwrap();
23− assert_eq!(Some(file.path()), doc.path().map(PathBuf::as_path));
24− assert_eq!(&Severity::Error, app.editor.get_status().unwrap().1);
25− }),
26− false,
27− )
28− .await?;
29−
30− Ok(())
31−}
32−
33−#[tokio::test(flavor = "multi_thread")]
34−async fn test_buffer_close_concurrent() -> anyhow::Result<()> {
35− test_key_sequences(
36− &mut helpers::AppBuilder::new().build()?,
37− vec![
38− (
39− None,
40− Some(&|app| {
41− assert_eq!(1, app.editor.documents().count());
42− assert!(!app.editor.is_err());
43− }),
44− ),
45− (
46− Some("ihello<esc>:new<ret>"),
47− Some(&|app| {
48− assert_eq!(2, app.editor.documents().count());
49− assert!(!app.editor.is_err());
50− }),
51− ),
52− (
53− Some(":buffer<minus>close<ret>"),
54− Some(&|app| {
55− assert_eq!(1, app.editor.documents().count());
56− assert!(!app.editor.is_err());
57− }),
58− ),
59− ],
60− false,
61− )
62− .await?;
63−
64− // verify if writes are queued up, it finishes them before closing the buffer
65− let mut file = tempfile::NamedTempFile::new()?;
66− let mut command = String::new();
67− const RANGE: RangeInclusive<i32> = 1..=1000;
68−
69− for i in RANGE {
70− let cmd = format!("%c{}<esc>:w!<ret>", i);
71− command.push_str(&cmd);
72− }
73−
74− command.push_str(":buffer<minus>close<ret>");
75−
76− let mut app = helpers::AppBuilder::new()
77− .with_file(file.path(), None)
78− .build()?;
79−
80− test_key_sequence(
81− &mut app,
82− Some(&command),
83− Some(&|app| {
84− assert!(!app.editor.is_err(), "error: {:?}", app.editor.get_status());
85−
86− let doc = app.editor.document_by_path(file.path());
87− assert!(doc.is_none(), "found doc: {:?}", doc);
88− }),
89− false,
90− )
91− .await?;
92−
93− helpers::assert_file_has_content(file.as_file_mut(), &RANGE.end().to_string())?;
94−
95− Ok(())
96−}
97
6
98#[tokio::test(flavor = "multi_thread")]
7#[tokio::test(flavor = "multi_thread")]
99async fn test_selection_duplication() -> anyhow::Result<()> {
8async fn test_selection_duplication() -> anyhow::Result<()> {
helix-term/tests/test/write.rs → helix-term/tests/test/commands/write.rsrenamed+92−2
@@ -1,5 +1,5 @@
1use std::{
1use std::{
2− io::{Read, Seek, SeekFrom, Write},
2+ io::{Read, Seek, Write},
3 ops::RangeInclusive,
3 ops::RangeInclusive,
4};
4};
5
5
@@ -8,6 +8,96 @@ use helix_view::doc;
8
8
9use super::*;
9use super::*;
10
10
11+#[tokio::test(flavor = "multi_thread")]
12+async fn test_write_quit_fail() -> anyhow::Result<()> {
13+ let file = helpers::new_readonly_tempfile()?;
14+ let mut app = helpers::AppBuilder::new()
15+ .with_file(file.path(), None)
16+ .build()?;
17+
18+ test_key_sequence(
19+ &mut app,
20+ Some("ihello<esc>:wq<ret>"),
21+ Some(&|app| {
22+ let mut docs: Vec<_> = app.editor.documents().collect();
23+ assert_eq!(1, docs.len());
24+
25+ let doc = docs.pop().unwrap();
26+ assert_eq!(Some(file.path()), doc.path().map(PathBuf::as_path));
27+ assert_eq!(&Severity::Error, app.editor.get_status().unwrap().1);
28+ }),
29+ false,
30+ )
31+ .await?;
32+
33+ Ok(())
34+}
35+
36+#[tokio::test(flavor = "multi_thread")]
37+async fn test_buffer_close_concurrent() -> anyhow::Result<()> {
38+ test_key_sequences(
39+ &mut helpers::AppBuilder::new().build()?,
40+ vec![
41+ (
42+ None,
43+ Some(&|app| {
44+ assert_eq!(1, app.editor.documents().count());
45+ assert!(!app.editor.is_err());
46+ }),
47+ ),
48+ (
49+ Some("ihello<esc>:new<ret>"),
50+ Some(&|app| {
51+ assert_eq!(2, app.editor.documents().count());
52+ assert!(!app.editor.is_err());
53+ }),
54+ ),
55+ (
56+ Some(":buffer<minus>close<ret>"),
57+ Some(&|app| {
58+ assert_eq!(1, app.editor.documents().count());
59+ assert!(!app.editor.is_err());
60+ }),
61+ ),
62+ ],
63+ false,
64+ )
65+ .await?;
66+
67+ // verify if writes are queued up, it finishes them before closing the buffer
68+ let mut file = tempfile::NamedTempFile::new()?;
69+ let mut command = String::new();
70+ const RANGE: RangeInclusive<i32> = 1..=1000;
71+
72+ for i in RANGE {
73+ let cmd = format!("%c{}<esc>:w!<ret>", i);
74+ command.push_str(&cmd);
75+ }
76+
77+ command.push_str(":buffer<minus>close<ret>");
78+
79+ let mut app = helpers::AppBuilder::new()
80+ .with_file(file.path(), None)
81+ .build()?;
82+
83+ test_key_sequence(
84+ &mut app,
85+ Some(&command),
86+ Some(&|app| {
87+ assert!(!app.editor.is_err(), "error: {:?}", app.editor.get_status());
88+
89+ let doc = app.editor.document_by_path(file.path());
90+ assert!(doc.is_none(), "found doc: {:?}", doc);
91+ }),
92+ false,
93+ )
94+ .await?;
95+
96+ helpers::assert_file_has_content(file.as_file_mut(), &RANGE.end().to_string())?;
97+
98+ Ok(())
99+}
100+
11#[tokio::test(flavor = "multi_thread")]
101#[tokio::test(flavor = "multi_thread")]
12async fn test_write() -> anyhow::Result<()> {
102async fn test_write() -> anyhow::Result<()> {
13 let mut file = tempfile::NamedTempFile::new()?;
103 let mut file = tempfile::NamedTempFile::new()?;
@@ -57,7 +147,7 @@ async fn test_overwrite_protection() -> anyhow::Result<()> {
57 file.as_file_mut().flush()?;
147 file.as_file_mut().flush()?;
58 file.as_file_mut().sync_all()?;
148 file.as_file_mut().sync_all()?;
59
149
60− file.seek(SeekFrom::Start(0))?;
150+ file.rewind()?;
61 let mut file_content = String::new();
151 let mut file_content = String::new();
62 file.as_file_mut().read_to_string(&mut file_content)?;
152 file.as_file_mut().read_to_string(&mut file_content)?;
63
153