Move most unit tests of declarative macro matchers into integration tests.

This should help to prevent future regressions of the type reported in #86 where the unit tests work only because they were compiled in the same crate as the declarative macros. That setup namely makes it too easy to forget to reference the crate when invoking another declarative macro in the expansion. By moving these tests to integration tests, they are compiled from outside the original crate and subject to the same rules as downstream dependencies.

See also https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html.

Also introduces the use of indoc in some of the moved tests in order to improve formatting. See https://crates.io/crates/indoc.

Author: hovinen

googletest/src/matchers/all_matcher.rs

@@ -152,45 +152,12 @@ mod tests {
     #[cfg(not(google3))]
     use googletest::matchers;
     use googletest::{
-        google_test,
+        all, google_test,
         matcher::{Matcher, MatcherResult},
         verify_that, Result,
     };
     use indoc::indoc;
-    use matchers::{contains_substring, displays_as, ends_with, eq, err, not, starts_with};
-
-    #[google_test]
-    fn matches_any_value_when_list_is_empty() -> Result<()> {
-        verify_that!((), all!())
-    }
-
-    #[google_test]
-    fn matches_value_with_single_matching_component() -> Result<()> {
-        verify_that!(123, all!(eq(123)))
-    }
-
-    #[google_test]
-    fn does_not_match_value_with_single_non_matching_component() -> Result<()> {
-        verify_that!(123, not(all!(eq(456))))
-    }
-
-    #[google_test]
-    fn matches_value_with_two_matching_components() -> Result<()> {
-        verify_that!("A string", all!(starts_with("A"), ends_with("string")))
-    }
-
-    #[google_test]
-    fn does_not_match_value_with_one_non_matching_component_among_two_components() -> Result<()> {
-        verify_that!(123, not(all!(eq(123), eq(456))))
-    }
-
-    #[google_test]
-    fn supports_trailing_comma() -> Result<()> {
-        verify_that!(
-            "An important string",
-            all!(starts_with("An"), contains_substring("important"), ends_with("string"),)
-        )
-    }
+    use matchers::{displays_as, ends_with, eq, starts_with};
 
     #[google_test]
     fn description_shows_more_than_one_matcher() -> Result<()> {
@@ -202,9 +169,9 @@ mod tests {
             matcher.describe(MatcherResult::Matches),
             eq(indoc!(
                 "
-                has all the following properties:
-                  * starts with prefix \"A\"
-                  * ends with suffix \"string\""
+            has all the following properties:
+              * starts with prefix \"A\"
+              * ends with suffix \"string\""
             ))
         )
     }
@@ -214,7 +181,10 @@ mod tests {
         let first_matcher = starts_with("A");
         let matcher: internal::AllMatcher<String, 1> = all!(first_matcher);
 
-        verify_that!(matcher.describe(MatcherResult::Matches), eq("starts with prefix \"A\""))
+        verify_that!(
+            matcher.describe(MatcherResult::Matches),
+            eq("starts with prefix \"A\"")
+        )
     }
 
     #[google_test]
@@ -240,39 +210,4 @@ mod tests {
             displays_as(eq("which does not start with \"Another\""))
         )
     }
-
-    #[google_test]
-    fn mismatch_description_two_failed_matchers() -> Result<()> {
-        verify_that!(
-            all!(starts_with("One"), starts_with("Two")).explain_match("Three"),
-            displays_as(eq(
-                "\n  * which does not start with \"One\"\n  * which does not start with \"Two\""
-            ))
-        )
-    }
-
-    #[google_test]
-    fn mismatch_description_empty_matcher() -> Result<()> {
-        verify_that!(all!().explain_match("Three"), displays_as(eq("which is anything")))
-    }
-
-    #[google_test]
-    fn all_multiple_failed_assertions() -> Result<()> {
-        let result = verify_that!(4, all![eq(1), eq(2), eq(3)]);
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(indoc!(
-                "
-                Value of: 4
-                Expected: has all the following properties:
-                  * is equal to 1
-                  * is equal to 2
-                  * is equal to 3
-                Actual: 4, 
-                  * which isn't equal to 1
-                  * which isn't equal to 2
-                  * which isn't equal to 3"
-            ))))
-        )
-    }
 }

googletest/src/matchers/elements_are_matcher.rs

@@ -153,112 +153,3 @@ pub mod internal {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #[cfg(not(google3))]
-    use crate as googletest;
-    use googletest::matcher::Matcher;
-    #[cfg(not(google3))]
-    use googletest::matchers;
-    use googletest::{google_test, verify_that, Result};
-    use indoc::indoc;
-    use matchers::{contains_substring, displays_as, eq, err, not};
-
-    #[google_test]
-    fn elements_are_matches_vector() -> Result<()> {
-        let value = vec![1, 2, 3];
-        verify_that!(value, elements_are![eq(1), eq(2), eq(3)])
-    }
-
-    #[google_test]
-    fn elements_are_matches_slice() -> Result<()> {
-        let value = vec![1, 2, 3];
-        let slice = value.as_slice();
-        verify_that!(*slice, elements_are![eq(1), eq(2), eq(3)])
-    }
-
-    #[google_test]
-    fn elements_are_matches_array() -> Result<()> {
-        verify_that!([1, 2, 3], elements_are![eq(1), eq(2), eq(3)])
-    }
-
-    #[google_test]
-    fn elements_are_supports_trailing_comma() -> Result<()> {
-        let value = vec![1, 2, 3];
-        verify_that!(value, elements_are![eq(1), eq(2), eq(3),])
-    }
-
-    #[google_test]
-    fn elements_are_returns_no_match_when_expected_and_actual_sizes_differ() -> Result<()> {
-        let value = vec![1, 2];
-        verify_that!(value, not(elements_are![eq(1), eq(2), eq(3)]))
-    }
-
-    #[google_test]
-    fn elements_are_produces_correct_failure_message() -> Result<()> {
-        let result = verify_that!(vec![1, 4, 3], elements_are![eq(1), eq(2), eq(3)]);
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(indoc!(
-                "
-                Value of: vec![1, 4, 3]
-                Expected: has elements:
-                  0. is equal to 1
-                  1. is equal to 2
-                  2. is equal to 3
-                Actual: [
-                    1,
-                    4,
-                    3,
-                ], where element #1 is 4, which isn't equal to 2"
-            ))))
-        )
-    }
-
-    #[google_test]
-    fn elements_are_produces_correct_failure_message_nested() -> Result<()> {
-        let result = verify_that!(
-            vec![vec![0, 1], vec![1, 2]],
-            elements_are![elements_are![eq(1), eq(2)], elements_are![eq(2), eq(3)]]
-        );
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(indoc!(
-                "
-                Value of: vec![vec! [0, 1], vec! [1, 2]]
-                Expected: has elements:
-                  0. has elements:
-                       0. is equal to 1
-                       1. is equal to 2
-                  1. has elements:
-                       0. is equal to 2
-                       1. is equal to 3
-                Actual: [
-                    [
-                        0,
-                        1,
-                    ],
-                    [
-                        1,
-                        2,
-                    ],
-                ], where:
-                  * element #0 is [0, 1], where:
-                      * element #0 is 0, which isn't equal to 1
-                      * element #1 is 1, which isn't equal to 2
-                  * element #1 is [1, 2], where:
-                      * element #0 is 1, which isn't equal to 2
-                      * element #1 is 2, which isn't equal to 3"
-            ))))
-        )
-    }
-
-    #[google_test]
-    fn elements_are_explain_match_wrong_size() -> Result<()> {
-        verify_that!(
-            elements_are![eq(1)].explain_match(&vec![1, 2]),
-            displays_as(eq("whose size is 2"))
-        )
-    }
-}

googletest/src/matchers/field_matcher.rs

@@ -121,7 +121,11 @@ pub mod internal {
         field_path: &'static str,
         inner: InnerMatcher,
     ) -> impl Matcher<OuterT> {
-        FieldMatcher { field_accessor, field_path, inner }
+        FieldMatcher {
+            field_accessor,
+            field_path,
+            inner,
+        }
     }
 
     struct FieldMatcher<OuterT, InnerT, InnerMatcher> {
@@ -165,137 +169,3 @@ pub mod internal {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #[cfg(not(google3))]
-    use crate as googletest;
-    use googletest::matcher::{Matcher, MatcherResult};
-    #[cfg(not(google3))]
-    use googletest::matchers;
-    use googletest::{google_test, verify_that, Result};
-    use matchers::{container_eq, contains_substring, displays_as, eq, err, not};
-
-    #[derive(Debug)]
-    struct IntField {
-        int: i32,
-    }
-
-    #[google_test]
-    fn field_matches_integer_field() -> Result<()> {
-        verify_that!(IntField { int: 32 }, field!(IntField.int, eq(32)))
-    }
-
-    #[derive(Debug)]
-    struct StringField {
-        strink: String,
-    }
-
-    #[google_test]
-    fn field_matches_string_field() -> Result<()> {
-        verify_that!(
-            StringField { strink: "yes".to_string() },
-            field!(StringField.strink, eq("yes"))
-        )
-    }
-
-    #[google_test]
-    fn field_error_message_shows_field_name_and_inner_matcher() -> Result<()> {
-        let matcher = field!(IntField.int, eq(31));
-
-        verify_that!(
-            matcher.describe(MatcherResult::Matches),
-            eq("has field `int`, which is equal to 31")
-        )
-    }
-
-    mod sub {
-        #[derive(Debug)]
-        pub struct SubStruct {
-            pub field: i32,
-        }
-    }
-
-    #[google_test]
-    fn struct_in_other_module_matches() -> Result<()> {
-        verify_that!(sub::SubStruct { field: 32 }, field!(sub::SubStruct.field, eq(32)))
-    }
-
-    #[derive(Debug)]
-    struct Tuple(i32, String);
-
-    #[google_test]
-    fn tuple_matches_with_index() -> Result<()> {
-        verify_that!(Tuple(32, "yes".to_string()), field!(Tuple.0, eq(32)))
-    }
-
-    #[google_test]
-    fn matches_enum_value() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            AValue(u32),
-        }
-        let value = AnEnum::AValue(123);
-
-        verify_that!(value, field!(AnEnum::AValue.0, eq(123)))
-    }
-
-    #[google_test]
-    fn shows_correct_failure_message_for_wrong_struct_entry() -> Result<()> {
-        #[derive(Debug)]
-        struct AStruct {
-            a: Vec<u32>,
-        }
-        let value = AStruct { a: vec![1] };
-
-        let result = verify_that!(value, field!(AStruct.a, container_eq([])));
-
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(
-                "which has field `a`, which contains the unexpected element 1"
-            )))
-        )
-    }
-
-    #[google_test]
-    fn does_not_match_enum_value_with_wrong_enum_variant() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            #[allow(dead_code)] // This variant is intentionally unused.
-            AValue(u32),
-            AnotherValue,
-        }
-        let value = AnEnum::AnotherValue;
-
-        verify_that!(value, not(field!(AnEnum::AValue.0, eq(123))))
-    }
-
-    #[google_test]
-    fn shows_correct_failure_message_for_wrong_enum_value() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            #[allow(dead_code)] // This variant is intentionally unused.
-            AValue {
-                a: u32,
-            },
-            AnotherValue,
-        }
-        let value = AnEnum::AnotherValue;
-
-        let result = verify_that!(value, field!(AnEnum::AValue.a, eq(123)));
-
-        verify_that!(result, err(displays_as(contains_substring("which has no field `a`"))))
-    }
-
-    #[google_test]
-    fn matches_struct_like_enum_value() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            AValue { a_field: u32 },
-        }
-        let value = AnEnum::AValue { a_field: 123 };
-
-        verify_that!(value, field!(AnEnum::AValue.a_field, eq(123)))
-    }
-}