move tests to environment.rs

Signed-off-by: Freyskeyd <[email protected]>

Author: Freyskeyd

src/assert.rs

@@ -3,7 +3,6 @@ use std::process::{Command, Stdio};
 use std::path::PathBuf;
 use std::vec::Vec;
 use std::io::Write;
-use std::convert::Into;
 
 use errors::*;
 use output::{OutputAssertion, OutputKind};
@@ -29,7 +28,7 @@ impl default::Default for Assert {
         Assert {
             cmd: vec!["cargo", "run", "--"]
                 .into_iter().map(String::from).collect(),
-            env: Environment::empty(),
+            env: Environment::inherit(),
             current_dir: None,
             expect_success: Some(true),
             expect_exit_code: None,
@@ -281,7 +280,6 @@ impl Assert {
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
-            .env_clear()
             .envs(self.env.clone().compile())
             .args(&args);
 

src/environment.rs

@@ -2,9 +2,9 @@
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Environment {
     /// Customized environment variables
-    pub vars: Vec<(String, String)>,
+    vars: Vec<(String, String)>,
     /// Define if the structure must inherit
-    pub inherit: bool,
+    inherit: bool,
 }
 
 impl Default for Environment {
@@ -67,7 +67,11 @@ impl Environment {
 
     /// Compile Environment object
     pub fn compile(&self) -> Vec<(String, String)> {
-        ::std::env::vars().chain(self.vars.clone()).collect()
+        if self.inherit {
+            ::std::env::vars().chain(self.vars.clone()).collect()
+        } else {
+            self.vars.clone()
+        }
     }
 }
 
@@ -82,7 +86,7 @@ pub trait EnvironmentItem {
     fn to_environment_tuple(&self) -> (String, String);
 }
 
-impl<'s, T: ToString, Z:ToString> EnvironmentItem for &'s (T, Z) {
+impl<'s, T: ToString, Z: ToString> EnvironmentItem for &'s (T, Z) {
     fn to_environment_tuple(&self) -> (String, String) {
         (self.0.to_string(), self.1.to_string())
     }
@@ -101,3 +105,92 @@ impl<'s, T> From<T> for Environment
     }
 }
 
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use ::Assert;
+
+    fn command() -> Assert {
+        Assert::command(&["printenv"])
+    }
+
+    #[test]
+    fn take_ownership() {
+        let x = Environment::inherit();
+
+        command()
+            .with_env(x.clone())
+            .with_env(&x)
+            .with_env(x);
+    }
+
+    #[test]
+    fn in_place_mod() {
+        let y = Environment::empty();
+
+        let y = y.insert("key", "value");
+
+        assert_eq!(y.compile(), vec![("key".to_string(), "value".to_string())]);
+    }
+
+    #[test]
+    fn in_place_mod2() {
+        let x = Environment::inherit();
+
+        assert!(command()
+            .with_env(&x.insert("key", "value").insert("key", "vv"))
+            .stdout().contains("key=vv")
+            .execute()
+            .is_ok());
+        // Granted, `insert` moved `x`, so we can no longer reference it, even
+        // though only a reference was passed to `with_env`
+    }
+
+    #[test]
+    fn in_place_mod3() {
+        // In-place modification while allowing later accesses to the `Environment`
+        let y = Environment::empty();
+        assert_eq!(y.clone().insert("key", "value").compile(), vec![("key".to_string(), "value".to_string())]);
+        assert!(command()
+            .with_env(y)
+            .stdout().not().contains("key=value")
+            .execute().is_ok());
+
+    }
+
+    #[test]
+    fn take_vec() {
+        let v = vec![("bar".to_string(), "baz".to_string())];
+
+        assert!(command().with_env(&vec![("bar", "baz")]).stdout().contains("bar=baz").execute().is_ok());
+        assert!(command().with_env(&v).stdout().contains("bar=baz").execute().is_ok());
+        assert!(command().with_env(&vec![("bar", "baz")]).stdout().isnt("").execute().is_ok());
+    }
+
+    #[test]
+    fn take_slice_of_strs() {
+        assert!(command().with_env(&[("bar", "BAZ")]).stdout().contains("bar=BAZ").execute().is_ok());
+        assert!(command().with_env(&[("bar", "BAZ")][..]).stdout().contains("bar=BAZ").execute().is_ok());
+        assert!(command().with_env([("bar", "BAZ")].as_ref()).stdout().contains("bar=BAZ").execute().is_ok());
+    }
+
+    #[test]
+    fn take_slice_of_strings() {
+        // same deal as above
+
+        assert!(command().with_env(&[("bar".to_string(), "BAZ".to_string())]).stdout().contains("bar=BAZ").execute().is_ok());
+        assert!(command().with_env(&[("bar".to_string(), "BAZ".to_string())][..]).stdout().contains("bar=BAZ").execute().is_ok());
+    }
+
+    #[test]
+    fn take_slice() {
+        assert!(command().with_env(&[("hey", "ho")]).stdout().contains("hey=ho").execute().is_ok());
+        assert!(command().with_env(&[("hey", "ho".to_string())]).stdout().contains("hey=ho").execute().is_ok());
+    }
+
+    #[test]
+    fn take_string_i32() {
+        assert!(command().with_env(&[("bar", 3 as i32)]).stdout().contains("bar=3").execute().is_ok());
+    }
+}