add e2e

Author: ityuany

e2e/src/exec_builder.rs

@@ -0,0 +1,73 @@
+use std::{env::current_dir, error::Error, path::PathBuf, process::Command};
+
+#[derive(Debug, Clone)]
+pub struct Executor {
+    pub current: PathBuf,
+    pub envs: Vec<(String, String)>,
+}
+
+impl Executor {
+    pub fn exec(&self, shell: &str) -> Result<String, Box<dyn Error>> {
+        let shell_vec = shell
+            .split(" ")
+            .map(|item| item.trim())
+            .collect::<Vec<&str>>();
+
+        if let Some((bin_name, args)) = shell_vec.split_first() {
+            let output = Command::new(bin_name)
+                .envs(self.envs.clone())
+                .args(args)
+                .current_dir(&self.current)
+                .output()?;
+
+            let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+            println!(
+                r##"
+Exec shell: {}
+Stdout: {}
+Stderr: {}
+        "##,
+                shell, stdout, stderr
+            );
+            Ok(stdout)
+        } else {
+            Err("Invalid shell command".into())
+        }
+    }
+}
+
+pub struct ExecBuilder {
+    executor: Executor,
+}
+
+impl ExecBuilder {
+    pub fn builder() -> Self {
+        Self {
+            executor: Executor {
+                current: PathBuf::new(),
+                envs: vec![],
+            },
+        }
+    }
+
+    pub fn current(&mut self, current: &PathBuf) -> &mut Self {
+        self.executor.current = current.clone();
+        self
+    }
+
+    pub fn envs(&mut self, envs: Vec<(String, String)>) -> &mut Self {
+        let binary_path = current_dir().unwrap().join("tests");
+        self.executor.envs = vec![
+            vec![("PATH".to_string(), binary_path.display().to_string())],
+            envs,
+        ]
+        .concat();
+        self
+    }
+
+    pub fn build(&self) -> Executor {
+        self.executor.clone()
+    }
+}

e2e/src/lib.rs

@@ -0,0 +1 @@
+pub mod exec_builder;

e2e/src/main.rs

@@ -0,0 +1 @@
+20.11.1

e2e/tests/features/node-proxy/.node-version

@@ -1,9 +1,12 @@
 use std::{
     env::current_dir,
     error::Error,
+    fs,
+    path::PathBuf,
     process::{Command, Output},
 };
 
+use e2e::exec_builder::ExecBuilder;
 use tempfile::tempdir;
 
 // #[cfg(windows)]
@@ -13,7 +16,11 @@ use tempfile::tempdir;
 
 const SNM_CMD: &str = "snm";
 
-fn exec(shell: &str, envs: &Vec<(&str, String)>) -> Result<Output, Box<dyn Error>> {
+fn exec(
+    shell: &str,
+    current: &PathBuf,
+    envs: &Vec<(&str, String)>,
+) -> Result<String, Box<dyn Error>> {
     let shell_vec = shell
         .split(" ")
         .map(|item| item.trim())
@@ -23,46 +30,48 @@ fn exec(shell: &str, envs: &Vec<(&str, String)>) -> Result<Output, Box<dyn Error
         let output = Command::new(bin_name)
             .envs(envs.clone())
             .args(args)
+            .current_dir(current)
             .output()?;
-        Ok(output)
+
+        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+        println!(
+            r##"
+Exec shell: {}
+Stdout: {}
+Stderr: {}
+        "##,
+            shell, stdout, stderr
+        );
+        Ok(stdout)
     } else {
         Err("Invalid shell command".into())
     }
 }
 
 #[test]
-fn test_install_node() -> Result<(), Box<dyn Error>> {
+fn should_auto_install() -> Result<(), Box<dyn Error>> {
     let node_version = "16.0.0";
 
     let dir = tempdir()?.path().to_path_buf();
 
-    let path_dir = current_dir()?.join("tests");
-
-    println!("Current dir: {:?}", path_dir);
+    let current_dir_path_buf = current_dir()?;
 
     let envs = vec![
-        ("PATH", path_dir.display().to_string()),
-        ("SNM_HOME_DIR", dir.display().to_string()),
-        ("SNM_NODE_INSTALL_STRATEGY", "auto".to_string()),
+        ("SNM_HOME_DIR".to_string(), dir.display().to_string()),
+        ("SNM_NODE_INSTALL_STRATEGY".to_string(), "auto".to_string()),
     ];
 
-    let install_output = exec(&format!("{} node install {}", SNM_CMD, node_version), &envs)?;
-    println!(
-        "Install stdout: {}",
-        String::from_utf8_lossy(&install_output.stdout)
-    );
-    println!(
-        "Install stderr: {}",
-        String::from_utf8_lossy(&install_output.stderr)
-    );
+    let executor = ExecBuilder::builder()
+        .current(&current_dir_path_buf)
+        .envs(envs)
+        .build();
+
+    executor.exec(&format!("{} node install {}", SNM_CMD, node_version))?;
+
+    let stdout = executor.exec(&format!("{} node list", SNM_CMD))?;
 
-    let list_output = exec(&format!("{} node list", SNM_CMD), &envs)?;
-    let stdout = String::from_utf8(list_output.stdout)?;
-    println!("List stdout: {}", &stdout);
-    println!(
-        "List stderr: {}",
-        String::from_utf8_lossy(&list_output.stderr)
-    );
     assert!(
         stdout.contains(node_version),
         "Expected to find node version {} in stdout, but got: {}",
@@ -72,3 +81,33 @@ fn test_install_node() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+#[test]
+fn should_auto_install_and_exec() -> Result<(), Box<dyn Error>> {
+    let dir = tempdir()?.path().to_path_buf();
+
+    let cwd = current_dir()?
+        .join("tests")
+        .join("features")
+        .join("node-proxy");
+
+    let node_version = fs::read_to_string(cwd.join(".node-version"))?;
+
+    let envs = vec![
+        ("SNM_HOME_DIR".to_string(), dir.display().to_string()),
+        ("SNM_NODE_INSTALL_STRATEGY".to_string(), "auto".to_string()),
+    ];
+
+    let executor = ExecBuilder::builder().current(&cwd).envs(envs).build();
+
+    let stdout = executor.exec("node -v")?;
+
+    assert!(
+        stdout.contains(node_version.as_str()),
+        "Expected to find node version {} in stdout, but got: {}",
+        node_version,
+        stdout
+    );
+
+    Ok(())
+}

e2e/tests/snm_install_test.rs

@@ -13,8 +13,12 @@ dev:
 
 qtest:
     echo "Running tests..."
-    cargo qtest
+    cargo test --workspace --exclude e2e -- --nocapture
 
 test:
     echo "Running tests..."
-    cargo t -- --nocapture
+    cargo test --workspace --exclude e2e -- --nocapture
+
+e2e:
+    echo "Running end-to-end tests..."
+    cargo test --package e2e -- --nocapture