Always instantiace matchers with their contructors in tests

Author: gcapizzi

src/matchers.rs

@@ -46,39 +46,32 @@ impl<E: std::fmt::Debug, A: PartialEq<E> + std::fmt::Debug> Matcher<A> for Equal
 #[cfg(test)]
 mod tests {
     use super::equal;
-    use super::EqualMatcher;
-    use crate::expect;
     use crate::Matcher;
 
     #[test]
     fn should_match_if_actual_equals_expected() {
-        assert!(EqualMatcher { expected: "foo" }.match_value(&"foo"))
+        assert!(equal("foo").match_value(&"foo"))
     }
 
     #[test]
     fn should_not_match_if_actual_does_not_equal_expected() {
-        assert!(!EqualMatcher { expected: "foo" }.match_value(&"bar"))
+        assert!(!equal("foo").match_value(&"bar"))
     }
 
     #[test]
     fn should_allow_comparisons_between_partialeq_values() {
-        assert!(EqualMatcher { expected: "foo" }.match_value(&String::from("foo")));
+        assert!(equal("foo").match_value(&String::from("foo")));
     }
 
     #[test]
     fn failure_messages() {
         assert_eq!(
-            EqualMatcher { expected: "foo" }.failure_message(&"bar"),
+            equal("foo").failure_message(&"bar"),
             String::from("\tExpected:\n\t\t\"bar\"\n\tto equal:\n\t\t\"foo\"")
         );
         assert_eq!(
-            EqualMatcher { expected: "foo" }.negated_failure_message(&"foo"),
+            equal("foo").negated_failure_message(&"foo"),
             String::from("\tExpected:\n\t\t\"foo\"\n\tnot to equal:\n\t\t\"foo\"")
         );
     }
-
-    #[test]
-    fn equal_should_construct_an_equal_matcher() {
-        expect(&"foo").to(equal("foo"))
-    }
 }

src/matchers/collection.rs

@@ -183,76 +183,53 @@ impl<T: std::cmp::Ord> Collection<T> for std::collections::BTreeSet<T> {
 
 #[cfg(test)]
 mod tests {
-    use super::{be_empty, contain, BeEmptyMatcher, Collection, ContainMatcher};
-    use crate::{expect, Matcher};
-    use std::marker::PhantomData;
+    use super::{be_empty, contain, Collection};
+    use crate::Matcher;
 
     #[test]
     fn contain_matcher_should_match_if_collection_contains_element() {
-        assert!(ContainMatcher { element: "foo" }.match_value(&vec!["foo"]))
+        assert!(contain("foo").match_value(&vec!["foo"]))
     }
 
     #[test]
     fn contain_matcher_should_not_match_if_collection_does_not_contain_element() {
-        assert!(!ContainMatcher { element: "foo" }.match_value(&vec!["bar"]))
+        assert!(!contain("foo").match_value(&vec!["bar"]))
     }
 
     #[test]
     fn contain_matcher_failure_messages() {
         assert_eq!(
-            ContainMatcher { element: "foo" }.failure_message(&vec!["bar"]),
+            contain("foo").failure_message(&vec!["bar"]),
             String::from("\tExpected:\n\t\t[\"bar\"]\n\tto contain:\n\t\t\"foo\"")
         );
         assert_eq!(
-            ContainMatcher { element: "foo" }.negated_failure_message(&vec!["foo"]),
+            contain("foo").negated_failure_message(&vec!["foo"]),
             String::from("\tExpected:\n\t\t[\"foo\"]\n\tnot to contain:\n\t\t\"foo\"")
         );
     }
 
-    #[test]
-    fn contain_should_construct_a_contain_matcher() {
-        expect(&vec!["foo", "bar"]).to(contain("foo"))
-    }
-
     #[test]
     fn be_empty_matcher_should_match_if_collection_is_empty() {
-        assert!(BeEmptyMatcher {
-            phantom: PhantomData
-        }
-        .match_value(&std::vec::Vec::<i32>::new()))
+        assert!(be_empty().match_value(&std::vec::Vec::<i32>::new()))
     }
 
     #[test]
     fn be_empty_matcher_should_not_match_if_collection_is_not_empty() {
-        assert!(!BeEmptyMatcher {
-            phantom: PhantomData
-        }
-        .match_value(&vec![42]))
+        assert!(!be_empty().match_value(&vec![42]))
     }
 
     #[test]
     fn be_empty_matcher_failure_messages() {
         assert_eq!(
-            BeEmptyMatcher {
-                phantom: PhantomData
-            }
-            .failure_message(&vec!["bar"]),
+            be_empty().failure_message(&vec!["bar"]),
             String::from("\tExpected:\n\t\t[\"bar\"]\n\tto be empty")
         );
         assert_eq!(
-            BeEmptyMatcher {
-                phantom: PhantomData
-            }
-            .negated_failure_message(&std::vec::Vec::<i32>::new()),
+            be_empty().negated_failure_message(&std::vec::Vec::<i32>::new()),
             String::from("\tExpected:\n\t\t[]\n\tnot to be empty")
         );
     }
 
-    #[test]
-    fn be_empty_should_construct_a_be_empty_matcher() {
-        expect(&std::vec::Vec::<i32>::new()).to(be_empty())
-    }
-
     #[test]
     fn arrays_with_up_to_256_elements_are_collections() {
         assert!([

src/matchers/option.rs

@@ -64,64 +64,50 @@ impl<T: std::cmp::PartialEq + std::fmt::Debug> Matcher<Option<T>> for NoneMatche
 
 #[cfg(test)]
 mod tests {
-    use super::be_none;
-    use super::be_some;
-    use super::NoneMatcher;
-    use super::SomeMatcher;
-    use crate::expect;
+    use super::{be_none, be_some};
     use crate::Matcher;
 
     #[test]
     fn some_matcher_should_match_if_actual_is_some() {
-        assert!(SomeMatcher {}.match_value(&Some("foo")))
+        assert!(be_some().match_value(&Some("foo")))
     }
 
     #[test]
     fn some_matcher_should_not_match_if_actual_is_none() {
-        assert!(!SomeMatcher {}.match_value(&None::<u32>))
+        assert!(!be_some().match_value(&None::<u32>))
     }
 
     #[test]
     fn some_matcher_failure_messages() {
         assert_eq!(
-            SomeMatcher {}.failure_message(&None::<&str>),
+            be_some().failure_message(&None::<&str>),
             String::from("\tExpected:\n\t\tNone\n\tto be a Some")
         );
         assert_eq!(
-            SomeMatcher {}.negated_failure_message(&Some("foo")),
+            be_some().negated_failure_message(&Some("foo")),
             String::from("\tExpected:\n\t\tSome(\"foo\")\n\tnot to be a Some")
         );
     }
 
-    #[test]
-    fn be_some_should_contruct_a_some_matcher() {
-        expect(&Some("thing")).to(be_some())
-    }
-
     #[test]
     fn none_matcher_should_match_if_actual_is_none() {
-        assert!(NoneMatcher {}.match_value(&None::<&str>))
+        assert!(be_none().match_value(&None::<&str>))
     }
 
     #[test]
     fn none_matcher_should_not_match_if_actual_is_some() {
-        assert!(!NoneMatcher {}.match_value(&Some("thing")))
+        assert!(!be_none().match_value(&Some("thing")))
     }
 
     #[test]
     fn none_matcher_failure_messages() {
         assert_eq!(
-            NoneMatcher {}.failure_message(&Some("foo")),
+            be_none().failure_message(&Some("foo")),
             String::from("\tExpected:\n\t\tSome(\"foo\")\n\tto be None")
         );
         assert_eq!(
-            NoneMatcher {}.negated_failure_message(&None::<&str>),
+            be_none().negated_failure_message(&None::<&str>),
             String::from("\tExpected:\n\t\tNone\n\tnot to be None")
         );
     }
-
-    #[test]
-    fn be_none_should_contruct_a_none_matcher() {
-        expect(&None::<&str>).to(be_none())
-    }
 }

src/matchers/path.rs

@@ -34,34 +34,27 @@ impl<T: std::fmt::Debug + AsRef<Path>> Matcher<T> for ExistMatcher {
 #[cfg(test)]
 mod tests {
     use super::exist;
-    use super::ExistMatcher;
-    use crate::expect;
     use crate::Matcher;
 
     #[test]
     fn should_match_if_actual_exists() {
-        assert!(ExistMatcher {}.match_value(&"./Cargo.toml"))
+        assert!(exist().match_value(&"./Cargo.toml"))
     }
 
     #[test]
     fn should_not_match_if_actual_is_none() {
-        assert!(!ExistMatcher {}.match_value(&"does_not_exist"))
+        assert!(!exist().match_value(&"does_not_exist"))
     }
 
     #[test]
     fn failure_messages() {
         assert_eq!(
-            ExistMatcher {}.failure_message(&"does_not_exist"),
+            exist().failure_message(&"does_not_exist"),
             String::from("\tExpected:\n\t\t\"does_not_exist\"\n\tto exist")
         );
         assert_eq!(
-            ExistMatcher {}.negated_failure_message(&"does_exist"),
+            exist().negated_failure_message(&"does_exist"),
             String::from("\tExpected:\n\t\t\"does_exist\"\n\tnot to exist")
         );
     }
-
-    #[test]
-    fn exist_should_contruct_an_exist_matcher() {
-        expect(&"./Cargo.toml").to(exist())
-    }
 }

src/matchers/result.rs

@@ -64,64 +64,50 @@ impl<T: std::fmt::Debug, E: std::fmt::Debug> Matcher<Result<T, E>> for ErrMatche
 
 #[cfg(test)]
 mod tests {
-    use super::be_err;
-    use super::be_ok;
-    use super::ErrMatcher;
-    use super::OkMatcher;
-    use crate::expect;
+    use super::{be_err, be_ok};
     use crate::Matcher;
 
     #[test]
     fn ok_matcher_should_match_if_actual_is_ok() {
-        assert!(OkMatcher {}.match_value(&Ok::<u32, &str>(42)))
+        assert!(be_ok().match_value(&Ok::<u32, &str>(42)))
     }
 
     #[test]
     fn ok_matcher_should_not_match_if_actual_is_err() {
-        assert!(!OkMatcher {}.match_value(&Err::<u32, &str>("boo")))
+        assert!(!be_ok().match_value(&Err::<u32, &str>("boo")))
     }
 
     #[test]
     fn ok_matcher_failure_messages() {
         assert_eq!(
-            OkMatcher {}.failure_message(&Err::<u32, &str>("boo")),
+            be_ok().failure_message(&Err::<u32, &str>("boo")),
             String::from("\tExpected:\n\t\tErr(\"boo\")\n\tto be Ok")
         );
         assert_eq!(
-            OkMatcher {}.negated_failure_message(&Ok::<u32, &str>(42)),
+            be_ok().negated_failure_message(&Ok::<u32, &str>(42)),
             String::from("\tExpected:\n\t\tOk(42)\n\tnot to be Ok")
         );
     }
 
-    #[test]
-    fn be_ok_should_contruct_an_ok_matcher() {
-        expect(&Ok::<u32, &str>(42)).to(be_ok())
-    }
-
     #[test]
     fn err_matcher_should_match_if_actual_is_an_err() {
-        assert!(ErrMatcher {}.match_value(&Err::<u32, &str>("boo")))
+        assert!(be_err().match_value(&Err::<u32, &str>("boo")))
     }
 
     #[test]
     fn err_matcher_should_not_match_if_actual_is_ok() {
-        assert!(!ErrMatcher {}.match_value(&Ok::<u32, &str>(42)))
+        assert!(!be_err().match_value(&Ok::<u32, &str>(42)))
     }
 
     #[test]
     fn err_matcher_failure_messages() {
         assert_eq!(
-            ErrMatcher {}.failure_message(&Ok::<u32, &str>(42)),
+            be_err().failure_message(&Ok::<u32, &str>(42)),
             String::from("\tExpected:\n\t\tOk(42)\n\tto be an Err")
         );
         assert_eq!(
-            ErrMatcher {}.negated_failure_message(&Err::<u32, &str>("boo")),
+            be_err().negated_failure_message(&Err::<u32, &str>("boo")),
             String::from("\tExpected:\n\t\tErr(\"boo\")\n\tnot to be an Err")
         );
     }
-
-    #[test]
-    fn be_err_should_contruct_an_err_matcher() {
-        expect(&Err::<u32, &str>("boo")).to(be_err())
-    }
 }

src/matchers/string.rs

@@ -52,34 +52,27 @@ impl<A: AsRef<str> + std::fmt::Debug, E: AsRef<str> + std::fmt::Debug> Matcher<A
 #[cfg(test)]
 mod tests {
     use super::match_regex;
-    use super::MatchRegexMatcher;
-    use crate::expect;
     use crate::Matcher;
 
     #[test]
     fn should_match_if_actual_matches_with_regex() {
-        assert!(MatchRegexMatcher { regex: "foo.*" }.match_value(&"foobar"))
+        assert!(match_regex("foo.*").match_value(&"foobar"))
     }
 
     #[test]
     fn should_not_match_if_actual_does_not_match_regex() {
-        assert!(!MatchRegexMatcher { regex: "foo.*" }.match_value(&"bar"))
+        assert!(!match_regex("foo.*").match_value(&"bar"))
     }
 
     #[test]
     fn failure_messages() {
         assert_eq!(
-            MatchRegexMatcher { regex: "foo.*" }.failure_message(&"bar"),
+            match_regex("foo.*").failure_message(&"bar"),
             String::from("\tExpected:\n\t\t\"bar\"\n\tto match regex:\n\t\t\"foo.*\"")
         );
         assert_eq!(
-            MatchRegexMatcher { regex: "foo.*" }.negated_failure_message(&"foobar"),
+            match_regex("foo.*").negated_failure_message(&"foobar"),
             String::from("\tExpected:\n\t\t\"foobar\"\n\tnot to match regex:\n\t\t\"foo.*\"")
         );
     }
-
-    #[test]
-    fn match_regex_should_construct_a_match_regex_matcher() {
-        expect(&"foobar").to(match_regex("foo.*"))
-    }
 }