mirror of https://github.com/chipsenkbeil/distant
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1465 lines
41 KiB
Rust
1465 lines
41 KiB
Rust
use crate::sshd::*;
|
|
use assert_fs::{prelude::*, TempDir};
|
|
use distant_core::{
|
|
data::{ChangeKindSet, Environment, FileType, Metadata},
|
|
DistantChannelExt, DistantClient,
|
|
};
|
|
use once_cell::sync::Lazy;
|
|
use predicates::prelude::*;
|
|
use rstest::*;
|
|
use std::{path::Path, time::Duration};
|
|
use test_log::test;
|
|
|
|
static TEMP_SCRIPT_DIR: Lazy<TempDir> = Lazy::new(|| TempDir::new().unwrap());
|
|
static SCRIPT_RUNNER: Lazy<String> = Lazy::new(|| String::from("bash"));
|
|
|
|
static ECHO_ARGS_TO_STDOUT_SH: Lazy<assert_fs::fixture::ChildPath> = Lazy::new(|| {
|
|
let script = TEMP_SCRIPT_DIR.child("echo_args_to_stdout.sh");
|
|
script
|
|
.write_str(indoc::indoc!(
|
|
r#"
|
|
#/usr/bin/env bash
|
|
printf "%s" "$*"
|
|
"#
|
|
))
|
|
.unwrap();
|
|
script
|
|
});
|
|
|
|
static ECHO_ARGS_TO_STDERR_SH: Lazy<assert_fs::fixture::ChildPath> = Lazy::new(|| {
|
|
let script = TEMP_SCRIPT_DIR.child("echo_args_to_stderr.sh");
|
|
script
|
|
.write_str(indoc::indoc!(
|
|
r#"
|
|
#/usr/bin/env bash
|
|
printf "%s" "$*" 1>&2
|
|
"#
|
|
))
|
|
.unwrap();
|
|
script
|
|
});
|
|
|
|
static ECHO_STDIN_TO_STDOUT_SH: Lazy<assert_fs::fixture::ChildPath> = Lazy::new(|| {
|
|
let script = TEMP_SCRIPT_DIR.child("echo_stdin_to_stdout.sh");
|
|
script
|
|
.write_str(indoc::indoc!(
|
|
r#"
|
|
#/usr/bin/env bash
|
|
while IFS= read; do echo "$REPLY"; done
|
|
"#
|
|
))
|
|
.unwrap();
|
|
script
|
|
});
|
|
|
|
static SLEEP_SH: Lazy<assert_fs::fixture::ChildPath> = Lazy::new(|| {
|
|
let script = TEMP_SCRIPT_DIR.child("sleep.sh");
|
|
script
|
|
.write_str(indoc::indoc!(
|
|
r#"
|
|
#!/usr/bin/env bash
|
|
sleep "$1"
|
|
"#
|
|
))
|
|
.unwrap();
|
|
script
|
|
});
|
|
|
|
static DOES_NOT_EXIST_BIN: Lazy<assert_fs::fixture::ChildPath> =
|
|
Lazy::new(|| TEMP_SCRIPT_DIR.child("does_not_exist_bin"));
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn read_file_should_fail_if_file_missing(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let path = temp.child("missing-file").path().to_path_buf();
|
|
|
|
let _ = client.read_file(path).await.unwrap_err();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn read_file_should_send_blob_with_file_contents(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
file.write_str("some file contents").unwrap();
|
|
|
|
let bytes = client.read_file(file.path().to_path_buf()).await.unwrap();
|
|
assert_eq!(bytes, b"some file contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn read_file_text_should_send_error_if_fails_to_read_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let path = temp.child("missing-file").path().to_path_buf();
|
|
|
|
let _ = client.read_file_text(path).await.unwrap_err();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn read_file_text_should_send_text_with_file_contents(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
file.write_str("some file contents").unwrap();
|
|
|
|
let text = client
|
|
.read_file_text(file.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(text, "some file contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn write_file_should_send_error_if_fails_to_write_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create a temporary path and add to it to ensure that there are
|
|
// extra components that don't exist to cause writing to fail
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("dir").child("test-file");
|
|
|
|
let _ = client
|
|
.write_file(file.path().to_path_buf(), b"some text".to_vec())
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also verify that we didn't actually create the file
|
|
file.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn write_file_should_send_ok_when_successful(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Path should point to a file that does not exist, but all
|
|
// other components leading up to it do
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
|
|
client
|
|
.write_file(file.path().to_path_buf(), b"some text".to_vec())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also verify that we actually did create the file
|
|
// with the associated contents
|
|
file.assert("some text");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn write_file_text_should_send_error_if_fails_to_write_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create a temporary path and add to it to ensure that there are
|
|
// extra components that don't exist to cause writing to fail
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("dir").child("test-file");
|
|
|
|
let _ = client
|
|
.write_file_text(file.path().to_path_buf(), "some text".to_string())
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also verify that we didn't actually create the file
|
|
file.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn write_file_text_should_send_ok_when_successful(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Path should point to a file that does not exist, but all
|
|
// other components leading up to it do
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
|
|
client
|
|
.write_file_text(file.path().to_path_buf(), "some text".to_string())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also verify that we actually did create the file
|
|
// with the associated contents
|
|
file.assert("some text");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn append_file_should_send_error_if_fails_to_create_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create a temporary path and add to it to ensure that there are
|
|
// extra components that don't exist to cause writing to fail
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("dir").child("test-file");
|
|
|
|
let _ = client
|
|
.append_file(file.path().to_path_buf(), b"some extra contents".to_vec())
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also verify that we didn't actually create the file
|
|
file.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn append_file_should_create_file_if_missing(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Don't create the file directly, but define path
|
|
// where the file should be
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
|
|
client
|
|
.append_file(file.path().to_path_buf(), b"some extra contents".to_vec())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Yield to allow chance to finish appending to file
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
|
|
// Also verify that we actually did create to the file
|
|
file.assert("some extra contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn append_file_should_send_ok_when_successful(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create a temporary file and fill it with some contents
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
file.write_str("some file contents").unwrap();
|
|
|
|
client
|
|
.append_file(file.path().to_path_buf(), b"some extra contents".to_vec())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Yield to allow chance to finish appending to file
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
|
|
// Also verify that we actually did append to the file
|
|
file.assert("some file contentssome extra contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn append_file_text_should_send_error_if_fails_to_create_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create a temporary path and add to it to ensure that there are
|
|
// extra components that don't exist to cause writing to fail
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("dir").child("test-file");
|
|
|
|
let _ = client
|
|
.append_file_text(file.path().to_path_buf(), "some extra contents".to_string())
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also verify that we didn't actually create the file
|
|
file.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn append_file_text_should_create_file_if_missing(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Don't create the file directly, but define path
|
|
// where the file should be
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
|
|
client
|
|
.append_file_text(file.path().to_path_buf(), "some extra contents".to_string())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Yield to allow chance to finish appending to file
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
|
|
// Also verify that we actually did create to the file
|
|
file.assert("some extra contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn append_file_text_should_send_ok_when_successful(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create a temporary file and fill it with some contents
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("test-file");
|
|
file.write_str("some file contents").unwrap();
|
|
|
|
client
|
|
.append_file_text(file.path().to_path_buf(), "some extra contents".to_string())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Yield to allow chance to finish appending to file
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
|
|
// Also verify that we actually did append to the file
|
|
file.assert("some file contentssome extra contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn dir_read_should_send_error_if_directory_does_not_exist(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let dir = temp.child("test-dir");
|
|
|
|
let _ = client
|
|
.read_dir(
|
|
dir.path().to_path_buf(),
|
|
/* depth */ 0,
|
|
/* absolute */ false,
|
|
/* canonicalize */ false,
|
|
/* include_root */ false,
|
|
)
|
|
.await
|
|
.unwrap_err();
|
|
}
|
|
|
|
// /root/
|
|
// /root/file1
|
|
// /root/link1 -> /root/sub1/file2
|
|
// /root/sub1/
|
|
// /root/sub1/file2
|
|
async fn setup_dir() -> assert_fs::TempDir {
|
|
let root_dir = assert_fs::TempDir::new().unwrap();
|
|
root_dir.child("file1").touch().unwrap();
|
|
|
|
let sub1 = root_dir.child("sub1");
|
|
sub1.create_dir_all().unwrap();
|
|
|
|
let file2 = sub1.child("file2");
|
|
file2.touch().unwrap();
|
|
|
|
let link1 = root_dir.child("link1");
|
|
link1.symlink_to_file(file2.path()).unwrap();
|
|
|
|
root_dir
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn dir_read_should_support_depth_limits(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create directory with some nested items
|
|
let root_dir = setup_dir().await;
|
|
|
|
let (entries, _) = client
|
|
.read_dir(
|
|
root_dir.path().to_path_buf(),
|
|
/* depth */ 1,
|
|
/* absolute */ false,
|
|
/* canonicalize */ false,
|
|
/* include_root */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(entries.len(), 3, "Wrong number of entries found");
|
|
|
|
assert_eq!(entries[0].file_type, FileType::File);
|
|
assert_eq!(entries[0].path, Path::new("file1"));
|
|
assert_eq!(entries[0].depth, 1);
|
|
|
|
assert_eq!(entries[1].file_type, FileType::Symlink);
|
|
assert_eq!(entries[1].path, Path::new("link1"));
|
|
assert_eq!(entries[1].depth, 1);
|
|
|
|
assert_eq!(entries[2].file_type, FileType::Dir);
|
|
assert_eq!(entries[2].path, Path::new("sub1"));
|
|
assert_eq!(entries[2].depth, 1);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn dir_read_should_support_unlimited_depth_using_zero(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create directory with some nested items
|
|
let root_dir = setup_dir().await;
|
|
|
|
let (entries, _) = client
|
|
.read_dir(
|
|
root_dir.path().to_path_buf(),
|
|
/* depth */ 0,
|
|
/* absolute */ false,
|
|
/* canonicalize */ false,
|
|
/* include_root */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(entries.len(), 4, "Wrong number of entries found");
|
|
|
|
assert_eq!(entries[0].file_type, FileType::File);
|
|
assert_eq!(entries[0].path, Path::new("file1"));
|
|
assert_eq!(entries[0].depth, 1);
|
|
|
|
assert_eq!(entries[1].file_type, FileType::Symlink);
|
|
assert_eq!(entries[1].path, Path::new("link1"));
|
|
assert_eq!(entries[1].depth, 1);
|
|
|
|
assert_eq!(entries[2].file_type, FileType::Dir);
|
|
assert_eq!(entries[2].path, Path::new("sub1"));
|
|
assert_eq!(entries[2].depth, 1);
|
|
|
|
assert_eq!(entries[3].file_type, FileType::File);
|
|
assert_eq!(entries[3].path, Path::new("sub1").join("file2"));
|
|
assert_eq!(entries[3].depth, 2);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn dir_read_should_support_including_directory_in_returned_entries(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create directory with some nested items
|
|
let root_dir = setup_dir().await;
|
|
|
|
let (entries, _) = client
|
|
.read_dir(
|
|
root_dir.path().to_path_buf(),
|
|
/* depth */ 1,
|
|
/* absolute */ false,
|
|
/* canonicalize */ false,
|
|
/* include_root */ true,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(entries.len(), 4, "Wrong number of entries found");
|
|
|
|
// NOTE: Root entry is always absolute, resolved path
|
|
assert_eq!(entries[0].file_type, FileType::Dir);
|
|
assert_eq!(
|
|
entries[0].path,
|
|
dunce::canonicalize(root_dir.path()).unwrap()
|
|
);
|
|
assert_eq!(entries[0].depth, 0);
|
|
|
|
assert_eq!(entries[1].file_type, FileType::File);
|
|
assert_eq!(entries[1].path, Path::new("file1"));
|
|
assert_eq!(entries[1].depth, 1);
|
|
|
|
assert_eq!(entries[2].file_type, FileType::Symlink);
|
|
assert_eq!(entries[2].path, Path::new("link1"));
|
|
assert_eq!(entries[2].depth, 1);
|
|
|
|
assert_eq!(entries[3].file_type, FileType::Dir);
|
|
assert_eq!(entries[3].path, Path::new("sub1"));
|
|
assert_eq!(entries[3].depth, 1);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn dir_read_should_support_returning_absolute_paths(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create directory with some nested items
|
|
let root_dir = setup_dir().await;
|
|
|
|
let (entries, _) = client
|
|
.read_dir(
|
|
root_dir.path().to_path_buf(),
|
|
/* depth */ 1,
|
|
/* absolute */ true,
|
|
/* canonicalize */ false,
|
|
/* include_root */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(entries.len(), 3, "Wrong number of entries found");
|
|
let root_path = dunce::canonicalize(root_dir.path()).unwrap();
|
|
|
|
assert_eq!(entries[0].file_type, FileType::File);
|
|
assert_eq!(entries[0].path, root_path.join("file1"));
|
|
assert_eq!(entries[0].depth, 1);
|
|
|
|
assert_eq!(entries[1].file_type, FileType::Symlink);
|
|
assert_eq!(entries[1].path, root_path.join("link1"));
|
|
assert_eq!(entries[1].depth, 1);
|
|
|
|
assert_eq!(entries[2].file_type, FileType::Dir);
|
|
assert_eq!(entries[2].path, root_path.join("sub1"));
|
|
assert_eq!(entries[2].depth, 1);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn dir_read_should_support_returning_canonicalized_paths(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Create directory with some nested items
|
|
let root_dir = setup_dir().await;
|
|
|
|
let (entries, _) = client
|
|
.read_dir(
|
|
root_dir.path().to_path_buf(),
|
|
/* depth */ 1,
|
|
/* absolute */ false,
|
|
/* canonicalize */ true,
|
|
/* include_root */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(entries.len(), 3, "Wrong number of entries found");
|
|
println!("{:?}", entries);
|
|
|
|
assert_eq!(entries[0].file_type, FileType::File);
|
|
assert_eq!(entries[0].path, Path::new("file1"));
|
|
assert_eq!(entries[0].depth, 1);
|
|
|
|
// Symlink should be resolved from $ROOT/link1 -> $ROOT/sub1/file2
|
|
assert_eq!(entries[1].file_type, FileType::Symlink);
|
|
assert_eq!(entries[1].path, Path::new("sub1").join("file2"));
|
|
assert_eq!(entries[1].depth, 1);
|
|
|
|
assert_eq!(entries[2].file_type, FileType::Dir);
|
|
assert_eq!(entries[2].path, Path::new("sub1"));
|
|
assert_eq!(entries[2].depth, 1);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn create_dir_should_send_error_if_fails(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
|
|
// Make a path that has multiple non-existent components
|
|
// so the creation will fail
|
|
let root_dir = setup_dir().await;
|
|
let path = root_dir.path().join("nested").join("new-dir");
|
|
|
|
let _ = client
|
|
.create_dir(path.to_path_buf(), /* all */ false)
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also verify that the directory was not actually created
|
|
assert!(!path.exists(), "Path unexpectedly exists");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn create_dir_should_send_ok_when_successful(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let root_dir = setup_dir().await;
|
|
let path = root_dir.path().join("new-dir");
|
|
|
|
client
|
|
.create_dir(path.to_path_buf(), /* all */ false)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also verify that the directory was actually created
|
|
assert!(path.exists(), "Directory not created");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn create_dir_should_support_creating_multiple_dir_components(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let root_dir = setup_dir().await;
|
|
let path = root_dir.path().join("nested").join("new-dir");
|
|
|
|
client
|
|
.create_dir(path.to_path_buf(), /* all */ true)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also verify that the directory was actually created
|
|
assert!(path.exists(), "Directory not created");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn remove_should_send_error_on_failure(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("missing-file");
|
|
|
|
let _ = client
|
|
.remove(file.path().to_path_buf(), /* false */ false)
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also, verify that path does not exist
|
|
file.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn remove_should_support_deleting_a_directory(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let dir = temp.child("dir");
|
|
dir.create_dir_all().unwrap();
|
|
|
|
client
|
|
.remove(dir.path().to_path_buf(), /* false */ false)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also, verify that path does not exist
|
|
dir.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn remove_should_delete_nonempty_directory_if_force_is_true(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let dir = temp.child("dir");
|
|
dir.create_dir_all().unwrap();
|
|
dir.child("file").touch().unwrap();
|
|
|
|
client
|
|
.remove(dir.path().to_path_buf(), /* false */ true)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also, verify that path does not exist
|
|
dir.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn remove_should_support_deleting_a_single_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("some-file");
|
|
file.touch().unwrap();
|
|
|
|
client
|
|
.remove(file.path().to_path_buf(), /* false */ false)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Also, verify that path does not exist
|
|
file.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn copy_should_send_error_on_failure(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let src = temp.child("src");
|
|
let dst = temp.child("dst");
|
|
|
|
let _ = client
|
|
.copy(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also, verify that destination does not exist
|
|
dst.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn copy_should_support_copying_an_entire_directory(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
|
|
let src = temp.child("src");
|
|
src.create_dir_all().unwrap();
|
|
let src_file = src.child("file");
|
|
src_file.write_str("some contents").unwrap();
|
|
|
|
let dst = temp.child("dst");
|
|
let dst_file = dst.child("file");
|
|
|
|
client
|
|
.copy(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Verify that we have source and destination directories and associated contents
|
|
src.assert(predicate::path::is_dir());
|
|
src_file.assert(predicate::path::is_file());
|
|
dst.assert(predicate::path::is_dir());
|
|
dst_file.assert(predicate::path::eq_file(src_file.path()));
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn copy_should_support_copying_an_empty_directory(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let src = temp.child("src");
|
|
src.create_dir_all().unwrap();
|
|
let dst = temp.child("dst");
|
|
|
|
client
|
|
.copy(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Verify that we still have source and destination directories
|
|
src.assert(predicate::path::is_dir());
|
|
dst.assert(predicate::path::is_dir());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn copy_should_support_copying_a_directory_that_only_contains_directories(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
|
|
let src = temp.child("src");
|
|
src.create_dir_all().unwrap();
|
|
let src_dir = src.child("dir");
|
|
src_dir.create_dir_all().unwrap();
|
|
|
|
let dst = temp.child("dst");
|
|
let dst_dir = dst.child("dir");
|
|
|
|
client
|
|
.copy(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Verify that we have source and destination directories and associated contents
|
|
src.assert(predicate::path::is_dir().name("src"));
|
|
src_dir.assert(predicate::path::is_dir().name("src/dir"));
|
|
dst.assert(predicate::path::is_dir().name("dst"));
|
|
dst_dir.assert(predicate::path::is_dir().name("dst/dir"));
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn copy_should_support_copying_a_single_file(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let src = temp.child("src");
|
|
src.write_str("some text").unwrap();
|
|
let dst = temp.child("dst");
|
|
|
|
client
|
|
.copy(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Verify that we still have source and that destination has source's contents
|
|
src.assert(predicate::path::is_file());
|
|
dst.assert(predicate::path::eq_file(src.path()));
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn rename_should_fail_if_path_missing(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let src = temp.child("src");
|
|
let dst = temp.child("dst");
|
|
|
|
let _ = client
|
|
.rename(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap_err();
|
|
|
|
// Also, verify that destination does not exist
|
|
dst.assert(predicate::path::missing());
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn rename_should_support_renaming_an_entire_directory(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
|
|
let src = temp.child("src");
|
|
src.create_dir_all().unwrap();
|
|
let src_file = src.child("file");
|
|
src_file.write_str("some contents").unwrap();
|
|
|
|
let dst = temp.child("dst");
|
|
let dst_file = dst.child("file");
|
|
|
|
client
|
|
.rename(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Verify that we moved the contents
|
|
src.assert(predicate::path::missing());
|
|
src_file.assert(predicate::path::missing());
|
|
dst.assert(predicate::path::is_dir());
|
|
dst_file.assert("some contents");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn rename_should_support_renaming_a_single_file(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let src = temp.child("src");
|
|
src.write_str("some text").unwrap();
|
|
let dst = temp.child("dst");
|
|
|
|
client
|
|
.rename(src.path().to_path_buf(), dst.path().to_path_buf())
|
|
.await
|
|
.unwrap();
|
|
|
|
// Verify that we moved the file
|
|
src.assert(predicate::path::missing());
|
|
dst.assert("some text");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn watch_should_succeed(#[future] launched_client: Ctx<DistantClient>) {
|
|
// NOTE: Supporting multiple replies being sent back as part of creating, modifying, etc.
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
|
|
let file = temp.child("file");
|
|
file.touch().unwrap();
|
|
|
|
let _ = client
|
|
.watch(
|
|
file.path().to_path_buf(),
|
|
/* recursive */ false,
|
|
/* only */ ChangeKindSet::default(),
|
|
/* except */ ChangeKindSet::default(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn exists_should_send_true_if_path_exists(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.touch().unwrap();
|
|
|
|
let exists = client.exists(file.path().to_path_buf()).await.unwrap();
|
|
assert!(exists, "Expected exists to be true, but was false");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn exists_should_send_false_if_path_does_not_exist(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
|
|
let exists = client.exists(file.path().to_path_buf()).await.unwrap();
|
|
assert!(!exists, "Expected exists to be false, but was true");
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_send_error_on_failure(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
|
|
let _ = client
|
|
.metadata(
|
|
file.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap_err();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_send_back_metadata_on_file_if_exists(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.write_str("some text").unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
file.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(
|
|
matches!(
|
|
metadata,
|
|
Metadata {
|
|
canonicalized_path: None,
|
|
file_type: FileType::File,
|
|
len: 9,
|
|
readonly: false,
|
|
..
|
|
}
|
|
),
|
|
"{:?}",
|
|
metadata
|
|
);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_include_unix_specific_metadata_on_unix_platform(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.write_str("some text").unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
file.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
#[allow(clippy::match_single_binding)]
|
|
match metadata {
|
|
Metadata { unix, windows, .. } => {
|
|
assert!(unix.is_some(), "Unexpectedly missing unix metadata on unix");
|
|
assert!(
|
|
windows.is_none(),
|
|
"Unexpectedly got windows metadata on unix"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_include_windows_specific_metadata_on_windows_platform(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.write_str("some text").unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
file.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
#[allow(clippy::match_single_binding)]
|
|
match metadata {
|
|
Metadata { unix, windows, .. } => {
|
|
assert!(
|
|
windows.is_some(),
|
|
"Unexpectedly missing windows metadata on windows"
|
|
);
|
|
assert!(unix.is_none(), "Unexpectedly got unix metadata on windows");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_send_back_metadata_on_dir_if_exists(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let dir = temp.child("dir");
|
|
dir.create_dir_all().unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
dir.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(
|
|
matches!(
|
|
metadata,
|
|
Metadata {
|
|
canonicalized_path: None,
|
|
file_type: FileType::Dir,
|
|
readonly: false,
|
|
..
|
|
}
|
|
),
|
|
"{:?}",
|
|
metadata
|
|
);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_send_back_metadata_on_symlink_if_exists(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.write_str("some text").unwrap();
|
|
|
|
let symlink = temp.child("link");
|
|
symlink.symlink_to_file(file.path()).unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
symlink.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(
|
|
matches!(
|
|
metadata,
|
|
Metadata {
|
|
canonicalized_path: None,
|
|
file_type: FileType::Symlink,
|
|
readonly: false,
|
|
..
|
|
}
|
|
),
|
|
"{:?}",
|
|
metadata
|
|
);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_include_canonicalized_path_if_flag_specified(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.write_str("some text").unwrap();
|
|
|
|
let symlink = temp.child("link");
|
|
symlink.symlink_to_file(file.path()).unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
symlink.path().to_path_buf(),
|
|
/* canonicalize */ true,
|
|
/* resolve_file_type */ false,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
match metadata {
|
|
Metadata {
|
|
canonicalized_path: Some(path),
|
|
file_type: FileType::Symlink,
|
|
readonly: false,
|
|
..
|
|
} => assert_eq!(
|
|
path,
|
|
dunce::canonicalize(file.path()).unwrap(),
|
|
"Symlink canonicalized path does not match referenced file"
|
|
),
|
|
x => panic!("Unexpected response: {:?}", x),
|
|
}
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn metadata_should_resolve_file_type_of_symlink_if_flag_specified(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let file = temp.child("file");
|
|
file.write_str("some text").unwrap();
|
|
|
|
let symlink = temp.child("link");
|
|
symlink.symlink_to_file(file.path()).unwrap();
|
|
|
|
let metadata = client
|
|
.metadata(
|
|
symlink.path().to_path_buf(),
|
|
/* canonicalize */ false,
|
|
/* resolve_file_type */ true,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(
|
|
matches!(
|
|
metadata,
|
|
Metadata {
|
|
file_type: FileType::File,
|
|
..
|
|
}
|
|
),
|
|
"{:?}",
|
|
metadata
|
|
);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn proc_spawn_should_fail_if_process_not_found(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let _ = client
|
|
.spawn(
|
|
/* cmd */ DOES_NOT_EXIST_BIN.to_str().unwrap().to_string(),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap_err();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn proc_spawn_should_return_id_of_spawned_process(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!(
|
|
"{} {}",
|
|
*SCRIPT_RUNNER,
|
|
ECHO_ARGS_TO_STDOUT_SH.to_str().unwrap()
|
|
),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert!(proc.id() > 0);
|
|
}
|
|
|
|
// NOTE: Ignoring on windows because it's using WSL which wants a Linux path
|
|
// with / but thinks it's on windows and is providing \
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
#[cfg_attr(windows, ignore)]
|
|
async fn proc_spawn_should_send_back_stdout_periodically_when_available(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let mut proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!(
|
|
"{} {} some stdout",
|
|
*SCRIPT_RUNNER,
|
|
ECHO_ARGS_TO_STDOUT_SH.to_str().unwrap()
|
|
),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
proc.stdout.as_mut().unwrap().read().await.unwrap(),
|
|
b"some stdout"
|
|
);
|
|
assert!(
|
|
proc.wait().await.unwrap().success,
|
|
"Process should have completed successfully"
|
|
);
|
|
}
|
|
|
|
// NOTE: Ignoring on windows because it's using WSL which wants a Linux path
|
|
// with / but thinks it's on windows and is providing \
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
#[cfg_attr(windows, ignore)]
|
|
async fn proc_spawn_should_send_back_stderr_periodically_when_available(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let mut proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!(
|
|
"{} {} some stderr",
|
|
*SCRIPT_RUNNER,
|
|
ECHO_ARGS_TO_STDERR_SH.to_str().unwrap()
|
|
),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
proc.stderr.as_mut().unwrap().read().await.unwrap(),
|
|
b"some stderr"
|
|
);
|
|
assert!(
|
|
proc.wait().await.unwrap().success,
|
|
"Process should have completed successfully"
|
|
);
|
|
}
|
|
|
|
// NOTE: Ignoring on windows because it's using WSL which wants a Linux path
|
|
// with / but thinks it's on windows and is providing \
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
#[cfg_attr(windows, ignore)]
|
|
async fn proc_spawn_should_send_done_signal_when_completed(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!("{} {} 0.1", *SCRIPT_RUNNER, SLEEP_SH.to_str().unwrap()),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let _ = proc.wait().await.unwrap();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn proc_spawn_should_clear_process_from_state_when_killed(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let mut proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!("{} {} 1", *SCRIPT_RUNNER, SLEEP_SH.to_str().unwrap()),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Send kill signal
|
|
proc.kill().await.unwrap();
|
|
|
|
// Verify killed, which should be success false
|
|
let status = proc.wait().await.unwrap();
|
|
assert!(!status.success, "Process succeeded when killed")
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn proc_kill_should_fail_if_process_not_running(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let mut proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!("{} {} 1", *SCRIPT_RUNNER, SLEEP_SH.to_str().unwrap()),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Send kill signal
|
|
proc.kill().await.unwrap();
|
|
|
|
// Wait for process to be dead
|
|
let mut killer = proc.clone_killer();
|
|
let _ = proc.wait().await.unwrap();
|
|
|
|
// Now send it again, which should fail
|
|
let _ = killer.kill().await.unwrap_err();
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn proc_stdin_should_fail_if_process_not_running(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let mut proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!("{} {} 1", *SCRIPT_RUNNER, SLEEP_SH.to_str().unwrap()),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Send kill signal
|
|
proc.kill().await.unwrap();
|
|
|
|
// Wait for process to be dead
|
|
let mut stdin = proc.stdin.take().unwrap();
|
|
let _ = proc.wait().await.unwrap();
|
|
|
|
// Now send stdin, which should fail
|
|
let _ = stdin.write_str("some data").await.unwrap_err();
|
|
}
|
|
|
|
// NOTE: Ignoring on windows because it's using WSL which wants a Linux path
|
|
// with / but thinks it's on windows and is providing \
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
#[cfg_attr(windows, ignore)]
|
|
async fn proc_stdin_should_send_stdin_to_process(#[future] launched_client: Ctx<DistantClient>) {
|
|
let mut client = launched_client.await;
|
|
|
|
// First, run a program that listens for stdin
|
|
let mut proc = client
|
|
.spawn(
|
|
/* cmd */
|
|
format!(
|
|
"{} {}",
|
|
*SCRIPT_RUNNER,
|
|
ECHO_STDIN_TO_STDOUT_SH.to_str().unwrap()
|
|
),
|
|
/* environment */ Environment::new(),
|
|
/* current_dir */ None,
|
|
/* pty */ None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Second, send stdin to the remote process
|
|
proc.stdin
|
|
.as_mut()
|
|
.unwrap()
|
|
.write_str("hello world\n")
|
|
.await
|
|
.unwrap();
|
|
|
|
// Third, check the async response of stdout to verify we got stdin
|
|
assert_eq!(
|
|
proc.stdout.as_mut().unwrap().read_string().await.unwrap(),
|
|
"hello world\n"
|
|
);
|
|
}
|
|
|
|
#[rstest]
|
|
#[test(tokio::test)]
|
|
async fn system_info_should_return_system_info_based_on_binary(
|
|
#[future] launched_client: Ctx<DistantClient>,
|
|
) {
|
|
let mut client = launched_client.await;
|
|
|
|
let system_info = client.system_info().await.unwrap();
|
|
|
|
assert_eq!(system_info.family, std::env::consts::FAMILY.to_string());
|
|
assert_eq!(system_info.os, std::env::consts::OS.to_string());
|
|
assert_eq!(system_info.arch, std::env::consts::ARCH.to_string());
|
|
assert_eq!(system_info.main_separator, std::path::MAIN_SEPARATOR);
|
|
assert_ne!(system_info.username, "");
|
|
assert_ne!(system_info.shell, "");
|
|
}
|