move tests to environment.rs

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

Author: Freyskeyd

src/assert.rs

@@ -29,7 +29,7 @@ impl default::Default for Assert {
                 .into_iter()
                 .map(String::from)
                 .collect(),
-            env: Environment::empty(),
+            env: Environment::inherit(),
             current_dir: None,
             expect_success: Some(true),
             expect_exit_code: None,

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 {
@@ -25,7 +25,7 @@ impl Environment {
     /// extern crate assert_cli;
     ///
     /// let e = assert_cli::Environment::inherit().compile();
-    /// let e_ = ::std::env::vars();
+    /// let e_: Vec<(String, String)> = ::std::env::vars().collect();
     ///
     /// assert_eq!(e, e_);
     /// ```
@@ -57,17 +57,21 @@ impl Environment {
     /// ```rust
     /// extern crate assert_cli;
     ///
-    /// let e = assert_cli::Environment::empty().insert("boo", "bar").compile();
-    /// assert_eq!(e, vec![("foo", "bar")];
+    /// let e = assert_cli::Environment::empty().insert("foo", "bar").compile();
+    /// assert_eq!(e, vec![("foo".to_string(), "bar".to_string())]);
     /// ```
     pub fn insert<S1: Into<String>, S2: Into<String>>(mut self, key: S1, val: S2) -> Self {
         self.vars.push((key.into(), val.into()));
         self
     }
 
     /// Compile Environment object
-    pub fn compile(&self) -> Vec<(String, String)> {
-        ::std::env::vars().chain(self.vars.clone()).collect()
+    pub fn compile(self) -> Vec<(String, String)> {
+        if self.inherit {
+            ::std::env::vars().chain(self.vars).collect()
+        } else {
+            self.vars
+        }
     }
 }
 
@@ -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,102 @@ 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 empty_env() {
+        // In-place modification while allowing later accesses to the `Environment`
+        let y = Environment::empty();
+
+        assert!(command()
+            .with_env(y)
+            .stdout().is("")
+            .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());
+    }
+}