mirror of
https://github.com/helix-editor/helix.git
synced 2024-11-26 11:23:31 +04:00
f5991657f4
Prior to this change, every integration test which wanted its line endings to be handled transparently across platforms, i.e. test with the same input that has its platform's line feed characters, converting the line endings was up to each individual test by calling the `platform_line` helper function. This significantly increases the amount of boilerplate one has to copy between all the tests. However, there are some test cases that need to exert strict control over the exact input text without being manipulated behind the scenes by the test framework. So, with this change, the line feed conversions are factored into the `TestCase` struct. By default, line endings of the input text are converted to the platform's native line feed ending, but one can explicitly specify in their test case when the input text should be left alone and tested as is.
571 lines
16 KiB
Rust
571 lines
16 KiB
Rust
use std::{
|
|
io::{Read, Seek, Write},
|
|
ops::RangeInclusive,
|
|
};
|
|
|
|
use helix_core::diagnostic::Severity;
|
|
use helix_stdx::path;
|
|
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(&path::normalize(file.path())), doc.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(),
|
|
&LineFeedHandling::Native.apply(&RANGE.end().to_string()),
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
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 app,
|
|
Some("ithe gostak distims the doshes<ret><esc>:w<ret>"),
|
|
None,
|
|
false,
|
|
)
|
|
.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!(
|
|
LineFeedHandling::Native.apply("the gostak distims the doshes"),
|
|
file_content
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_overwrite_protection() -> anyhow::Result<()> {
|
|
let mut file = tempfile::NamedTempFile::new()?;
|
|
let mut app = helpers::AppBuilder::new()
|
|
.with_file(file.path(), None)
|
|
.build()?;
|
|
|
|
helpers::run_event_loop_until_idle(&mut app).await;
|
|
|
|
file.as_file_mut()
|
|
.write_all("extremely important content".as_bytes())?;
|
|
|
|
file.as_file_mut().flush()?;
|
|
file.as_file_mut().sync_all()?;
|
|
|
|
test_key_sequence(&mut app, Some(":x<ret>"), None, false).await?;
|
|
|
|
file.as_file_mut().flush()?;
|
|
file.as_file_mut().sync_all()?;
|
|
|
|
file.rewind()?;
|
|
let mut file_content = String::new();
|
|
file.as_file_mut().read_to_string(&mut file_content)?;
|
|
|
|
assert_eq!("extremely important content", file_content);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[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 app,
|
|
Some("ithe gostak distims the doshes<ret><esc>:wq<ret>"),
|
|
None,
|
|
true,
|
|
)
|
|
.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!(
|
|
LineFeedHandling::Native.apply("the gostak distims the doshes"),
|
|
file_content
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[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..=1000;
|
|
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 app, Some(&command), None, false).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!(
|
|
LineFeedHandling::Native.apply(&RANGE.end().to_string()),
|
|
file_content
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
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 app,
|
|
vec![
|
|
(
|
|
None,
|
|
Some(&|app| {
|
|
let doc = doc!(app.editor);
|
|
assert!(!doc.is_modified());
|
|
}),
|
|
),
|
|
(
|
|
Some("ihello<esc>"),
|
|
Some(&|app| {
|
|
let doc = doc!(app.editor);
|
|
assert!(doc.is_modified());
|
|
}),
|
|
),
|
|
(
|
|
Some(":w<ret>"),
|
|
Some(&|app| {
|
|
assert_eq!(&Severity::Error, app.editor.get_status().unwrap().1);
|
|
|
|
let doc = doc!(app.editor);
|
|
assert!(doc.is_modified());
|
|
}),
|
|
),
|
|
],
|
|
false,
|
|
)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
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(&path::normalize(file.path())), doc.path());
|
|
}),
|
|
false,
|
|
)
|
|
.await?;
|
|
|
|
helpers::assert_file_has_content(file.as_file_mut(), &LineFeedHandling::Native.apply("hello"))?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
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(flavor = "multi_thread")]
|
|
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_loader(helpers::test_syntax_loader(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(flavor = "multi_thread")]
|
|
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!(&path::normalize(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!(&path::normalize(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(),
|
|
&LineFeedHandling::Native.apply("i can eat glass, it will not hurt me\n"),
|
|
)?;
|
|
|
|
helpers::assert_file_has_content(
|
|
file2.as_file_mut(),
|
|
&LineFeedHandling::Native.apply("i can eat glass, it will not hurt me\n"),
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_fail_new_path() -> anyhow::Result<()> {
|
|
let file = helpers::new_readonly_tempfile()?;
|
|
|
|
test_key_sequences(
|
|
&mut AppBuilder::new().build()?,
|
|
vec![
|
|
(
|
|
None,
|
|
Some(&|app| {
|
|
let doc = doc!(app.editor);
|
|
assert_ne!(
|
|
Some(&Severity::Error),
|
|
app.editor.get_status().map(|status| status.1)
|
|
);
|
|
assert_eq!(None, doc.path());
|
|
}),
|
|
),
|
|
(
|
|
Some(&format!(":w {}<ret>", file.path().to_string_lossy())),
|
|
Some(&|app| {
|
|
let doc = doc!(app.editor);
|
|
assert_eq!(
|
|
Some(&Severity::Error),
|
|
app.editor.get_status().map(|status| status.1)
|
|
);
|
|
assert_eq!(None, doc.path());
|
|
}),
|
|
),
|
|
],
|
|
false,
|
|
)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_utf_bom_file() -> anyhow::Result<()> {
|
|
// "ABC" with utf8 bom
|
|
const UTF8_FILE: [u8; 6] = [0xef, 0xbb, 0xbf, b'A', b'B', b'C'];
|
|
|
|
// "ABC" in UTF16 with bom
|
|
const UTF16LE_FILE: [u8; 8] = [0xff, 0xfe, b'A', 0x00, b'B', 0x00, b'C', 0x00];
|
|
const UTF16BE_FILE: [u8; 8] = [0xfe, 0xff, 0x00, b'A', 0x00, b'B', 0x00, b'C'];
|
|
|
|
edit_file_with_content(&UTF8_FILE).await?;
|
|
edit_file_with_content(&UTF16LE_FILE).await?;
|
|
edit_file_with_content(&UTF16BE_FILE).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_insert_final_newline_added_if_missing() -> anyhow::Result<()> {
|
|
let mut file = tempfile::NamedTempFile::new()?;
|
|
let mut app = helpers::AppBuilder::new()
|
|
.with_file(file.path(), None)
|
|
.with_input_text("#[h|]#ave you tried chamomile tea?")
|
|
.build()?;
|
|
|
|
test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;
|
|
|
|
helpers::assert_file_has_content(
|
|
file.as_file_mut(),
|
|
&LineFeedHandling::Native.apply("have you tried chamomile tea?\n"),
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_insert_final_newline_unchanged_if_not_missing() -> anyhow::Result<()> {
|
|
let mut file = tempfile::NamedTempFile::new()?;
|
|
let mut app = helpers::AppBuilder::new()
|
|
.with_file(file.path(), None)
|
|
.with_input_text(LineFeedHandling::Native.apply("#[t|]#en minutes, please\n"))
|
|
.build()?;
|
|
|
|
test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;
|
|
|
|
helpers::assert_file_has_content(
|
|
file.as_file_mut(),
|
|
&LineFeedHandling::Native.apply("ten minutes, please\n"),
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_insert_final_newline_unchanged_if_missing_and_false() -> anyhow::Result<()> {
|
|
let mut file = tempfile::NamedTempFile::new()?;
|
|
let mut app = helpers::AppBuilder::new()
|
|
.with_config(Config {
|
|
editor: helix_view::editor::Config {
|
|
insert_final_newline: false,
|
|
..Default::default()
|
|
},
|
|
..Default::default()
|
|
})
|
|
.with_file(file.path(), None)
|
|
.with_input_text("#[t|]#he quiet rain continued through the night")
|
|
.build()?;
|
|
|
|
test_key_sequence(&mut app, Some(":w<ret>"), None, false).await?;
|
|
|
|
helpers::assert_file_has_content(
|
|
file.as_file_mut(),
|
|
"the quiet rain continued through the night",
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_all_insert_final_newline_add_if_missing_and_modified() -> anyhow::Result<()> {
|
|
let mut file1 = tempfile::NamedTempFile::new()?;
|
|
let mut file2 = tempfile::NamedTempFile::new()?;
|
|
let mut app = helpers::AppBuilder::new()
|
|
.with_file(file1.path(), None)
|
|
.with_input_text("#[w|]#e don't serve time travelers here")
|
|
.build()?;
|
|
|
|
test_key_sequence(
|
|
&mut app,
|
|
Some(&format!(
|
|
":o {}<ret>ia time traveler walks into a bar<esc>:wa<ret>",
|
|
file2.path().to_string_lossy()
|
|
)),
|
|
None,
|
|
false,
|
|
)
|
|
.await?;
|
|
|
|
helpers::assert_file_has_content(
|
|
file1.as_file_mut(),
|
|
&LineFeedHandling::Native.apply("we don't serve time travelers here\n"),
|
|
)?;
|
|
|
|
helpers::assert_file_has_content(
|
|
file2.as_file_mut(),
|
|
&LineFeedHandling::Native.apply("a time traveler walks into a bar\n"),
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_write_all_insert_final_newline_do_not_add_if_unmodified() -> anyhow::Result<()> {
|
|
let mut file = tempfile::NamedTempFile::new()?;
|
|
let mut app = helpers::AppBuilder::new()
|
|
.with_file(file.path(), None)
|
|
.build()?;
|
|
|
|
file.write_all(b"i lost on Jeopardy!")?;
|
|
file.rewind()?;
|
|
|
|
test_key_sequence(&mut app, Some(":wa<ret>"), None, false).await?;
|
|
|
|
helpers::assert_file_has_content(file.as_file_mut(), "i lost on Jeopardy!")?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn edit_file_with_content(file_content: &[u8]) -> anyhow::Result<()> {
|
|
let mut file = tempfile::NamedTempFile::new()?;
|
|
|
|
file.as_file_mut().write_all(&file_content)?;
|
|
|
|
helpers::test_key_sequence(
|
|
&mut helpers::AppBuilder::new()
|
|
.with_config(Config {
|
|
editor: helix_view::editor::Config {
|
|
insert_final_newline: false,
|
|
..Default::default()
|
|
},
|
|
..Default::default()
|
|
})
|
|
.build()?,
|
|
Some(&format!(":o {}<ret>:x<ret>", file.path().to_string_lossy())),
|
|
None,
|
|
true,
|
|
)
|
|
.await?;
|
|
|
|
file.rewind()?;
|
|
let mut new_file_content: Vec<u8> = Vec::new();
|
|
file.read_to_end(&mut new_file_content)?;
|
|
|
|
assert_eq!(file_content, new_file_content);
|
|
|
|
Ok(())
|
|
}
|