Clean up tests, restructure csm into lib+bin crate

Author: relrod

Cargo.lock

@@ -26,6 +26,7 @@ tar = "0.4.44"
 
 [dev-dependencies]
 assert_cmd = "2.0"
+clap_builder = "4.5.51"
 predicates = { version = "3.0", features = ["regex"] }
 regex = "1.12.2"
 temp-env = "0.3.6"

Cargo.toml

@@ -0,0 +1,6 @@
+pub mod csmrc;
+pub mod env;
+pub mod init;
+pub mod micromamba;
+pub mod robot;
+pub mod shell;

src/lib.rs

@@ -1,11 +1,9 @@
-mod csmrc;
-mod env;
-mod init;
-mod micromamba;
-mod robot;
-mod shell;
-
-use crate::csmrc::Config;
+use csm::csmrc::Config;
+use csm::env;
+use csm::init;
+use csm::robot;
+use csm::shell;
+
 use clap::{CommandFactory, Parser, Subcommand};
 use log::{LevelFilter, debug, error, info, warn};
 use std::fmt;

src/main.rs

@@ -2,19 +2,21 @@
 
 use assert_cmd::cargo::{self, cargo_bin_cmd};
 use assert_cmd::cmd::Command;
+use std::io::Write;
 use std::path::PathBuf;
-use tempfile::{Builder, TempDir};
+use std::{env, fs, io};
+use tempfile::{Builder, NamedTempFile, TempDir};
 
 #[derive(Debug)]
 pub enum Error {
     Which(which::Error),
-    IO(std::io::Error),
+    IO(io::Error),
     Regex(regex::Error),
     GenericError(String),
 }
 
-impl From<std::io::Error> for Error {
-    fn from(err: std::io::Error) -> Self {
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
         Self::IO(err)
     }
 }
@@ -64,7 +66,7 @@ impl Csm {
         command
     }
 
-    pub fn ext_command(&self, bin: PathBuf) -> Command {
+    pub fn ext_command(&self, bin: &str) -> Command {
         let mut command = Command::new(bin);
         self.prepare_command(&mut command);
 
@@ -76,7 +78,7 @@ impl Csm {
             .to_string_lossy()
             .replace("\\", "/");
         let separator = if cfg!(windows) { ";" } else { ":" };
-        let path = match std::env::var("PATH") {
+        let path = match env::var("PATH") {
             Ok(path) => format!("{}{}{}", path, separator, csm_bin_dir),
             Err(_) => csm_bin_dir,
         };
@@ -85,8 +87,48 @@ impl Csm {
         command
     }
 
-    pub fn write_csmrc(&self, config: &str) -> Result<(), std::io::Error> {
-        std::fs::write(self.home_dir.path().join(".csmrc"), config)
+    /// Similar to `ext_command`, but stores a script in a temporary file
+    /// (outside of the temporary home directory).
+    ///
+    /// This primarily exists because when reading from stdin, PowerShell will
+    /// by default insist on displaying its prompt and name banner, unlike every
+    /// other shell in existence.
+    pub fn run_script(&self, bin: &str, script: &str, suffix: &str) -> io::Result<ScriptCommand> {
+        let mut tmpfile = NamedTempFile::with_suffix(suffix)?;
+        writeln!(tmpfile, "{}", script)?;
+        let mut cmd = self.ext_command(bin);
+        cmd.arg(tmpfile.path());
+        Ok(ScriptCommand {
+            command: cmd,
+            _tmpfile: tmpfile,
+        })
+    }
+
+    pub fn write_csmrc(&self, config: &str) -> Result<(), io::Error> {
+        fs::write(self.home_dir.path().join(".csmrc"), config)
+    }
+}
+
+/// This exists only to make sure that the tmpfile doesn't get dropped
+/// prematurely from Csm.run_script(). The tmpfile will get dropped when the
+/// reference to it goes away - so we need a way to keep the reference around
+/// with the Command that we return.
+pub struct ScriptCommand {
+    pub command: Command,
+    _tmpfile: NamedTempFile,
+}
+
+impl std::ops::Deref for ScriptCommand {
+    type Target = Command;
+
+    fn deref(&self) -> &Self::Target {
+        &self.command
+    }
+}
+
+impl std::ops::DerefMut for ScriptCommand {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.command
     }
 }
 

tests/common.rs

@@ -3,7 +3,6 @@ mod common;
 use common::Error;
 
 use predicates::prelude::*;
-use which::which;
 
 /// Create an environment with `csm env create`.
 fn csm_env_create(csm: &mut common::Csm, name: &str) -> Result<(), Error> {
@@ -167,29 +166,29 @@ fn csm_env_activate_deactivate_bash() -> Result<(), Error> {
     let _ = csm_env_create(&mut csm, "csm_env_activate_bash");
 
     // activate
-    csm.ext_command(which("bash")?)
-        .arg("-c")
-        .arg(
-            "eval \"$(csm init bash --code)\" &&\
+    csm.run_script(
+        "bash",
+        "eval \"$(csm init bash --code)\" &&\
              csm env activate -n csm_env_activate_bash &&\
              robot --version",
-        )
-        .assert()
-        .code(251)
-        .stdout(predicate::str::is_match("^Robot Framework")?);
+        ".sh",
+    )?
+    .assert()
+    .code(251)
+    .stdout(predicate::str::is_match("^Robot Framework")?);
 
     // deactivate
-    csm.ext_command(which("bash")?)
-        .arg("-c")
-        .arg(
-            "eval \"$(csm init bash --code)\" &&\
+    csm.run_script(
+        "bash",
+        "eval \"$(csm init bash --code)\" &&\
              csm env activate -n csm_env_activate_bash &&\
              csm env deactivate &&\
              robot --version",
-        )
-        .assert()
-        .failure()
-        .stderr(predicate::str::contains("command not found"));
+        ".sh",
+    )?
+    .assert()
+    .failure()
+    .stderr(predicate::str::contains("command not found"));
     Ok(())
 }
 
@@ -202,29 +201,28 @@ fn csm_env_activate_deactivate_powershell() -> Result<(), Error> {
     let _ = csm_env_create(&mut csm, "csm_env_activate_bash");
 
     // activate
-    csm.ext_command(which("pwsh")?)
-        .arg("-c")
-        .arg(format!(
-            "csm init powershell --code | Out-String | Invoke-Expression &&\
+    csm.run_script(
+        "pwsh",
+        "csm init powershell --code | Out-String | Invoke-Expression &&\
              csm env activate -n csm_env_activate_bash &&\
              robot --version",
-        ))
-        .assert()
-        .stdout(predicate::str::is_match("^Robot Framework")?);
+        ".ps1",
+    )?
+    .assert()
+    .stdout(predicate::str::is_match("^Robot Framework")?);
 
     // deactivate
-    csm.ext_command(which("pwsh")?)
-        .arg("-c")
-        .arg(format!(
-            "csm init powershell --code | Out-String | Invoke-Expression &&\
+    csm.run_script(
+        "pwsh",
+        "csm init powershell --code | Out-String | Invoke-Expression &&\
              csm env activate -n csm_env_activate_bash &&\
              csm env deactivate &&\
              robot --version",
-        ))
-        .assert()
-        .failure()
-        .stderr(predicate::str::contains(
-            "not recognized as a name of a cmdlet",
-        ));
+        ".ps1",
+    )?
+    .assert()
+    .stderr(predicate::str::contains(
+        "not recognized as a name of a cmdlet",
+    ));
     Ok(())
 }