move tests to environment.rs

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

Author: Freyskeyd

.travis.yml

@@ -11,14 +11,14 @@ matrix:
     env: CLIPPY_VERS="0.0.165"
     before_script: |
       [[ "$(cargo +nightly-2017-10-09 clippy --version)" != "$CLIPPY_VERS" ]] && \
-      cargo +nightly-2017-10-09 install clippy --vers "$CLIPPY_VERS" --force
+      cargo +nightly-2017-10-09 install clippy --vers "$CLIPPY_VERS" --force || true
     script: |
       cargo +nightly-2017-10-09 clippy -- -D warnings
   - rust: nightly-2017-10-09
     env: RUSTFMT_VERS="0.2.8"
     before_script: |
       [[ "$(cargo +nightly-2017-10-09 fmt -- --version)" != "$RUSTFMT_VERS"* ]] && \
-      cargo +nightly-2017-10-09 install rustfmt-nightly --vers "$RUSTFMT_VERS" --force
+      cargo +nightly-2017-10-09 install rustfmt-nightly --vers "$RUSTFMT_VERS" --force || true
     script: |
       cargo +nightly-2017-10-09 fmt --all -- --write-mode=diff
 before_script:

README.md

@@ -1,5 +1,5 @@
 # Assert CLI
-
+ 
 > **Test CLI Applications** - This crate checks the output of a child process is as expected.
 
 [![Build Status](https://travis-ci.org/killercup/assert_cli.svg)](https://travis-ci.org/killercup/assert_cli) [![Documentation](https://img.shields.io/badge/docs-master-blue.svg)][Documentation]

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,22 +86,210 @@ 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())
     }
 }
 
 impl<'s, T> From<T> for Environment
-    where T: IntoIterator, T::Item: EnvironmentItem
+where
+    T: IntoIterator,
+    T::Item: EnvironmentItem,
 {
     fn from(v: T) -> Self {
         Self {
-            vars: v.into_iter()
-                .map(|k| k.to_environment_tuple())
-                .collect(),
+            vars: v.into_iter().map(|k| k.to_environment_tuple()).collect(),
             inherit: false,
         }
     }
 }
 
+
+#[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()
+        );
+    }
+}