134 lines
4.0 KiB
Rust
134 lines
4.0 KiB
Rust
use nextsync::config::config::Config;
|
|
use rand::{distributions::Alphanumeric, Rng};
|
|
use std::env;
|
|
use std::fs::{self, File};
|
|
use std::io::{self, Write};
|
|
use std::path::PathBuf;
|
|
use std::process::{Command, Output};
|
|
use std::str;
|
|
|
|
pub struct ClientTest {
|
|
volume: String, // temp dir for the test
|
|
pub test_id: String, // name of the test (e.g nextsync_rand)
|
|
exe_path: PathBuf, // absolute path of nextsync executable
|
|
}
|
|
|
|
pub fn get_random_test_id() -> String {
|
|
rand::thread_rng()
|
|
.sample_iter(&Alphanumeric)
|
|
.take(4)
|
|
.map(char::from)
|
|
.collect()
|
|
}
|
|
|
|
impl ClientTest {
|
|
pub fn new(id: &str) -> Self {
|
|
let mut test_id = id.to_string();
|
|
test_id.push_str("_");
|
|
test_id.push_str(&get_random_test_id());
|
|
|
|
// create a directory in /tmp with the given id
|
|
let mut vol = String::from("/tmp/nextsync/");
|
|
vol.push_str(&test_id);
|
|
let _ = fs::remove_dir_all(&vol);
|
|
let _ = fs::create_dir_all(&vol);
|
|
|
|
// get nextsync path
|
|
let mut exe_path = env::current_dir().unwrap();
|
|
exe_path = exe_path.join("target/debug/nextsync");
|
|
|
|
// build the client
|
|
ClientTest {
|
|
volume: vol,
|
|
test_id,
|
|
exe_path,
|
|
}
|
|
}
|
|
|
|
pub fn init(mut self) -> Self {
|
|
self.exec_ok("init");
|
|
println!("========== {} ========== ", &self.test_id);
|
|
|
|
// set remote url
|
|
// let url = String::from(format!("{}@nextcloud.local/{}", self.user, self.test_id));
|
|
// self.run_cmd_ok(&format!("remote add origin {}", url));
|
|
|
|
// // set force_unsecure as debug server has not certificate
|
|
// self.run_cmd_ok("config set force_insecure true");
|
|
|
|
// // set token for request
|
|
// self.run_cmd_ok(&format!("credential add {} {}", self.user, self.user));
|
|
self
|
|
}
|
|
|
|
pub fn get_config(&self) -> Config {
|
|
Config::from(Some(&self.volume))
|
|
}
|
|
|
|
pub fn ok(self) -> io::Result<()> {
|
|
fs::remove_dir_all(&self.volume)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn exec_ok(&mut self, args: &str) -> Output {
|
|
let output = self.exec(args);
|
|
if !output.status.success() {
|
|
println!("id: {}", self.test_id.clone());
|
|
println!("Failed to execute: '{}'", args);
|
|
println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
|
|
println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
|
|
}
|
|
assert!(output.status.success());
|
|
output
|
|
}
|
|
|
|
pub fn exec(&mut self, args: &str) -> Output {
|
|
let output = Command::new(self.exe_path.to_str().unwrap())
|
|
.current_dir(self.volume.clone())
|
|
.args(args.split(" "))
|
|
.output()
|
|
.expect("Could not execute nextsync command");
|
|
return output;
|
|
}
|
|
|
|
pub fn add_dir(&mut self, name: &str) -> std::io::Result<()> {
|
|
let mut path = self.volume.clone();
|
|
path.push_str("/");
|
|
path.push_str(name);
|
|
let _ = fs::create_dir_all(path)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn add_file(&mut self, name: &str, content: &str) -> std::io::Result<()> {
|
|
let mut path = self.volume.clone();
|
|
path.push_str("/");
|
|
path.push_str(name);
|
|
|
|
let mut file = File::create(path)?;
|
|
file.write_all(content.as_bytes())?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn remove_file(&mut self, name: &str) -> std::io::Result<()> {
|
|
let mut path = self.volume.clone();
|
|
path.push_str("/");
|
|
path.push_str(name);
|
|
fs::remove_file(path)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn remove_dir(&mut self, name: &str) -> std::io::Result<()> {
|
|
let mut path = self.volume.clone();
|
|
path.push_str("/");
|
|
path.push_str(name);
|
|
fs::remove_dir_all(path)?;
|
|
Ok(())
|
|
}
|
|
|
|
// pub fn has_file(&mut self, file: &str, content: &str) -> bool {
|
|
// let full_path = PathBuf::from(self.volume.clone()).join(file);
|
|
|
|
// // has_files(full_path, file, content, self.test_id.clone())
|
|
// }
|
|
}
|