refactor(test): use subdir

tests/push.rs

@@ -0,0 +1,37 @@
+use rand::{distributions::Alphanumeric, Rng};
+
+mod utils;
+use utils::{server::ServerTest, client::ClientTest};
+
+
+fn get_random_test_id() -> String {
+    let mut id: String = rand::thread_rng()
+        .sample_iter(&Alphanumeric)
+        .take(7)
+        .map(char::from)
+        .collect();
+    id.push_str("_nextsync");
+    id.to_owned()
+}
+
+#[cfg(test)]
+mod push_tests {
+    use super::*;
+
+    #[test]
+    fn simple_push() {
+        let id = get_random_test_id();
+        let mut server = ServerTest::new(id.clone()).init();
+        let mut client = ClientTest::new(id).init();
+
+        let _ = client.add_file("file1", "foo");
+        client.run_cmd_ok("add file1");
+        client.run_cmd_ok("push");
+
+        // tests
+        assert!(server.has_file("file1", "foo"));
+
+        client.clean();
+        server.clean();
+    }
+}

tests/tests.rs

@@ -1,216 +0,0 @@
-use std::process::{Command, Output};
-use std::os::unix::fs::PermissionsExt;
-use rand::{distributions::Alphanumeric, Rng}; // 0.8
-use std::fs::{self, File, Permissions};
-use std::io::{Write, BufReader, BufRead};
-use std::env;
-use std::path::PathBuf;
-
-struct ServerTest {
-    user: String,
-    volume: PathBuf,
-    test_id: String
-}
-
-impl ServerTest {
-    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
-        }
-    }
-
-    fn init(mut self) -> Self {
-        self.add_dir(self.test_id.clone());
-        self.volume = self.volume.join(self.test_id.clone());
-        self.sync_test()
-    }
-
-    fn clean(mut self) -> Self {
-        self.remove_dir(self.test_id.clone());
-        self.sync_root()
-    }
-
-    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
-    }
-
-    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
-    }
-
-    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;
-    }
-}
-
-struct ClientTest {
-    user: String,
-    volume: String,
-    test_id: String,
-    exe_path: PathBuf,
-}
-
-impl ClientTest {
-    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 
-        }
-    }
-
-    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
-    }
-
-    fn clean(self) -> Self {
-        let _ = fs::remove_dir_all(&self.volume);
-        self
-    }
-
-    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
-    }
-
-    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;
-    }
-
-    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(())
-    }
-}
-
-fn get_random_test_id() -> String {
-    let mut id: String = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(7)
-        .map(char::from)
-        .collect();
-    id.push_str("_nextsync");
-    id.to_owned()
-}
-
-#[test]
-fn test1() {
-    let id = get_random_test_id();
-    dbg!(id.clone());
-    let mut server = ServerTest::new(id.clone()).init();
-    let mut client = ClientTest::new(id).init();
-
-    let _ = client.add_file("file1", "foo");
-    client.run_cmd_ok("add file1");
-    client.run_cmd_ok("push");
-
-    // tests
-    assert!(server.has_file("file1", "foo"));
-
-    client.clean();
-    server.clean();
-}

tests/utils.rs

@@ -0,0 +1,5 @@
+#[path = "utils/server.rs"]
+pub mod server;
+
+#[path = "utils/client.rs"]
+pub mod client;

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;
+    }
+}
+