refactor(test): use subdir

tests/utils/client.rs

@@ -0,0 +1,86 @@
+use std::process::{Command, Output};
+use std::fs::{self, File};
+use std::io::Write;
+use std::env;
+use std::path::PathBuf;
+
+pub struct ClientTest {
+    user: String,
+    volume: String,
+    test_id: String,
+    exe_path: PathBuf,
+}
+
+impl ClientTest {
+    pub fn new(id: String) -> Self {
+
+        // create a directory in /tmp with the given id
+        let mut vol = String::from("/tmp/");
+        vol.push_str(&id);
+        let _ = fs::create_dir(vol.clone());
+
+        // get nextsync path
+        let mut exe_path = env::current_dir().unwrap();
+        exe_path = exe_path.join("target/debug/nextsync");
+
+        let _ = env::set_current_dir(vol.clone());
+
+        // build the client
+        ClientTest {
+            user: String::from("admin"),
+            volume: vol,
+            test_id: id,
+            exe_path 
+        }
+    }
+
+    pub fn init(mut self) -> Self {
+        self.run_cmd_ok("init");
+
+        // 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 clean(self) -> Self {
+        let _ = fs::remove_dir_all(&self.volume);
+        self
+    }
+
+    pub fn run_cmd_ok(&mut self, args: &str) -> Output {
+        let output = self.run_cmd(args);
+        if !output.status.success() {
+            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 run_cmd(&mut self, args: &str) -> Output {
+        let output = Command::new(self.exe_path.to_str().unwrap())
+            .args(args.split(" "))
+            .output()
+            .expect("Could not execute nextsync command");
+        return output;
+    }
+
+    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(())
+    }
+}

tests/utils/server.rs

@@ -0,0 +1,109 @@
+use std::process::Command;
+use std::os::unix::fs::PermissionsExt;
+use std::fs::{self, File, Permissions};
+use std::io::{BufReader, BufRead};
+use std::env;
+use std::path::PathBuf;
+
+#[cfg(test)]
+pub struct ServerTest {
+    user: String,
+    volume: PathBuf,
+    test_id: String
+}
+
+#[cfg(test)]
+impl ServerTest {
+    pub fn new(id: String) -> Self {
+        let mut volume = env::current_dir().unwrap();
+        volume = volume.join("tests/data/admin/files");
+
+        ServerTest {
+            user: String::from("admin"),
+            volume,
+            test_id: id
+        }
+    }
+
+    pub fn init(mut self) -> Self {
+        self.add_dir(self.test_id.clone());
+        self.volume = self.volume.join(self.test_id.clone());
+        self.sync_test()
+    }
+
+    pub fn clean(mut self) -> Self {
+        self.remove_dir(self.test_id.clone());
+        self.sync_root()
+    }
+
+    pub fn add_dir(&mut self, path: String) -> &mut ServerTest {
+        let mut full_path = self.volume.clone();
+        full_path.push(path);
+
+        match fs::create_dir(&full_path) {
+            Ok(_) => {
+                // Set permissions to 777 to allow nextcloud to access it (workaround avoiding to
+                // set group and owner to www-data)
+                if let Err(e) = fs::set_permissions(&full_path, Permissions::from_mode(0o777)) {
+                    eprintln!("Error setting permissions: {}", e);
+                }
+            },
+            Err(e) => eprintln!("Error creating directory: {}", e),
+        }
+
+        self
+    }
+
+    pub fn remove_dir(&mut self, path: String) -> &mut ServerTest {
+        let mut full_path = self.volume.clone();
+        full_path.push(path);
+
+        let _ = fs::remove_dir_all(&full_path);
+        self
+    }
+
+    fn sync_root(self) -> Self {
+        self.sync("")
+    }
+
+    fn sync_test(self) -> Self {
+        let test_id = self.test_id.clone();
+        self.sync(&test_id)
+    }
+
+    fn sync(self, path: &str) -> Self {
+        // perform the occ files:scan command inside the nextcloud docker container
+
+        let nextcloud_docker = "master-nextcloud-1";
+        let mut args = String::from("exec -ti --user www-data");
+        args.push_str(nextcloud_docker);
+        args.push_str("/var/www/html/occ files:scan --path=/");
+        args.push_str(&self.user);
+        args.push_str("files/");
+        args.push_str(path);
+
+        let _output = Command::new("docker")
+            .args(args.split(" "))
+            .output()
+            .expect("Could not execute nextsync command");
+        self
+    }
+
+    pub fn has_file(&mut self, file: &str, content: &str) -> bool {
+        let full_path = self.volume.clone().join(file);
+
+        if !full_path.exists() {
+            eprintln!("File '{}' does't exists", file);
+            return false;
+        }
+
+        let file = File::open(full_path).unwrap();
+        for line in BufReader::new(file).lines(){
+            if let Ok(line) = line {
+                return line == content;
+            }
+        }
+        return false;
+    }
+}
+