Add a shim to ease integration with the [proptest](https://crates.io/crates/proptest) crate.

Previously, it was awkward to use GoogleTest Rust assertions in Proptest property tests and to return GoogleTest `Result` from such tests. This required a fair amount of manual type conversion.

This adds two trait implementations behind an optional dependency on the `proptest` crate:

 * An implementation of 'IntoTestResult` allows easily converting the output of `TestRunner` into a GoogleTest `Result`.
 * An implementation of `From<TestAssertionFailure>` for `TestCaseError` allows easily using GoogleTest macros such as `verify_that!` inside `TestRunner::run`.

In particular, with this change, it is much easier to have property-based tests using `proptest` which do not panic on failure but rather communicate failures using `Result`, as is idiomatic in GoogleTest.

Since proptest requires Rust 1.60, this also modifies the CI action so that the test against Rust 1.59 only runs with the --no-default-features flag.

This also adds a section on integrations to the crate-level documentation covering both the new proptest integration and the existing [anyhow](https://crates.io/crates/anyhow) integration.

Author: hovinen

.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
     name: test / ubuntu / ${{ matrix.toolchain }}
     strategy:
       matrix:
-        toolchain: [stable, 1.59.0, nightly, beta]
+        toolchain: [stable, nightly, beta]
     steps:
       - uses: actions/checkout@v3
       - name: Install ${{ matrix.toolchain }}
@@ -62,7 +62,7 @@ jobs:
     name: test (no default features) / ubuntu / ${{ matrix.toolchain }}
     strategy:
       matrix:
-        toolchain: [stable]
+        toolchain: [stable, 1.59]
     steps:
       - uses: actions/checkout@v3
       - name: Install ${{ matrix.toolchain }}

googletest/Cargo.toml

@@ -32,10 +32,11 @@ authors = [
 
 [dependencies]
 googletest_macro = { path = "../googletest_macro", version = "0.8.1" }
+ansi_term = "0.12.0"
 anyhow = { version = "1", optional = true }
 num-traits = "0.2.15"
 regex = "1.6.0"
-ansi_term = "0.12.0"
+proptest = { version = "1.2.0", optional = true }
 
 [dev-dependencies]
 indoc = "2"

googletest/crate_docs.md

@@ -360,5 +360,62 @@ fn always_fails() -> Result<()> {
 # always_fails().unwrap_err();
 ```
 
+## Integrations with other crates
+
+GoogleTest Rust includes integrations with the
+[`anyhow`](https://crates.io/crates/anyhow) and
+[`proptest`](https://crates.io/crates/proptest) crates to simplify turning
+errors from those crates into test failures.
+
+To use this, activate the `anyhow`, respectively `proptest` feature in
+GoogleTest Rust and invoke the extension method [`into_test_result()`] on a
+`Result` value in your test. For example:
+
+```
+# use googletest::prelude::*;
+# #[cfg(feature = "anyhow")]
+# use anyhow::anyhow;
+# #[cfg(feature = "anyhow")]
+# /* The attribute macro would prevent the function from being compiled in a doctest.
+#[test]
+# */
+fn has_anyhow_failure() -> Result<()> {
+    Ok(just_return_error().into_test_result()?)
+}
+
+# #[cfg(feature = "anyhow")]
+fn just_return_error() -> anyhow::Result<()> {
+    anyhow::Result::Err(anyhow!("This is an error"))
+}
+# #[cfg(feature = "anyhow")]
+# has_anyhow_failure().unwrap_err();
+```
+
+One can convert `proptest` test failures into GoogleTest test failures when the
+test is invoked with
+[`TestRunner::run`](https://docs.rs/proptest/latest/proptest/test_runner/struct.TestRunner.html#method.run):
+
+```
+# use googletest::prelude::*;
+# #[cfg(feature = "proptest")]
+# use proptest::test_runner::{Config, TestRunner};
+# #[cfg(feature = "proptest")]
+# /* The attribute macro would prevent the function from being compiled in a doctest.
+#[test]
+# */
+fn numbers_are_greater_than_zero() -> Result<()> {
+    let mut runner = TestRunner::new(Config::default());
+    runner.run(&(1..100i32), |v| Ok(verify_that!(v, gt(0))?)).into_test_result()
+}
+# #[cfg(feature = "proptest")]
+# numbers_are_greater_than_zero().unwrap();
+```
+
+Similarly, when the `proptest` feature is enabled, GoogleTest assertion failures
+can automatically be converted into `proptest`
+[`TestCaseError`](https://docs.rs/proptest/latest/proptest/test_runner/enum.TestCaseError.html)
+through the `?` operator as the example above shows.
+
 [`and_log_failure()`]: GoogleTestSupport::and_log_failure
+[`into_test_result()`]: IntoTestResult::into_test_result
 [`Matcher`]: matcher::Matcher

googletest/src/internal/test_outcome.rs

@@ -163,3 +163,10 @@ impl<T: std::error::Error> From<T> for TestAssertionFailure {
         TestAssertionFailure::create(format!("{value}"))
     }
 }
+
+#[cfg(feature = "proptest")]
+impl From<TestAssertionFailure> for proptest::test_runner::TestCaseError {
+    fn from(value: TestAssertionFailure) -> Self {
+        proptest::test_runner::TestCaseError::Fail(format!("{value}").into())
+    }
+}

googletest/src/lib.rs

@@ -232,3 +232,12 @@ impl<T> IntoTestResult<T> for std::result::Result<T, anyhow::Error> {
         self.map_err(|e| TestAssertionFailure::create(format!("{e}")))
     }
 }
+
+#[cfg(feature = "proptest")]
+impl<OkT, CaseT: std::fmt::Debug> IntoTestResult<OkT>
+    for std::result::Result<OkT, proptest::test_runner::TestError<CaseT>>
+{
+    fn into_test_result(self) -> std::result::Result<OkT, TestAssertionFailure> {
+        self.map_err(|e| TestAssertionFailure::create(format!("{e}")))
+    }
+}

googletest/tests/lib.rs

@@ -19,5 +19,7 @@ mod field_matcher_test;
 mod matches_pattern_test;
 mod pointwise_matcher_test;
 mod property_matcher_test;
+#[cfg(feature = "proptest")]
+mod proptest_integration_test;
 mod tuple_matcher_test;
 mod unordered_elements_are_matcher_test;

googletest/tests/proptest_integration_test.rs

@@ -0,0 +1,30 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg(feature = "proptest")]
+
+use googletest::prelude::*;
+use proptest::test_runner::{Config, TestRunner};
+
+#[test]
+fn numbers_are_greater_than_zero() -> Result<()> {
+    let mut runner = TestRunner::new(Config::default());
+    runner.run(&(1..100i32), |v| Ok(verify_that!(v, gt(0))?)).into_test_result()
+}
+
+#[test]
+fn strings_are_nonempty() -> Result<()> {
+    let mut runner = TestRunner::new(Config::default());
+    runner.run(&"[a-zA-Z0-9]+", |v| Ok(verify_that!(v, not(eq("")))?)).into_test_result()
+}