Add support for easily converting anyhow errors into test failures.

This allows more easily returning early from functions returning `anyhow::Error` in conjunction with the `?` operator.

Unfortunately, `anyhow::Error` does not implement `std::error::Error`, so it will not work transparently with the `?` operator. Furthermore, one cannot add a `From<anyhow::Error>` implementation, since theoretically `anyhow::Error` could implement `std::error::Error` in the future, which would then break this crate.

The solution here is to introduce a new trait `IntoTestResult` which is then implemented for `anyhow::Error` and which provides a method `into_test_result()` to do the conversion. The anyhow crate is now an optional dependency enabled by a feature.

This also adds a CI job which tests the library with no default features enabled. This ensures that the library still compiles and works if the downstream dependency does not enable optional dependencies.

PiperOrigin-RevId: 524766870

Author: hovinenb

.github/workflows/ci.yml

@@ -57,6 +57,24 @@ jobs:
       - name: cargo test --locked
         run: cargo test --locked --all-features
 
+  test-no-default-features:
+    runs-on: ubuntu-latest
+    name: test (no default features) / ubuntu / ${{ matrix.toolchain }}
+    strategy:
+      matrix:
+        toolchain: [stable]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install ${{ matrix.toolchain }}
+        uses: dtolnay/rust-toolchain@b44cb146d03e8d870c57ab64b80f04586349ca5d
+        with:
+          toolchain: ${{ matrix.toolchain }}
+      - name: cargo generate-lockfile
+        if: hashFiles('Cargo.lock') == ''
+        run: cargo generate-lockfile
+      - name: cargo test --locked
+        run: cargo test --locked --no-default-features
+
   integration-test:
     runs-on: ubuntu-latest
     name: integration-test / ubuntu / ${{ matrix.toolchain }}

googletest/Cargo.toml

@@ -37,6 +37,7 @@ doctest = false
 googletest_macro = { path = "../googletest_macro", version = "0.4.2" }
 num-traits = "0.2.15"
 regex = "1.6.0"
+anyhow = { version = "1.0.70", optional = true }
 indoc = { version = "2", optional = true }
 rstest = { version = "0.17.0", optional = true }
 
@@ -120,6 +121,12 @@ name = "simple_assertion_failure_with_assert_that"
 path = "integration_tests/simple_assertion_failure_with_assert_that.rs"
 test = false
 
+[[bin]]
+name = "test_returning_anyhow_error"
+path = "integration_tests/test_returning_anyhow_error.rs"
+test = false
+required-features = ["anyhow"]
+
 [[bin]]
 name = "two_expect_pred_failures"
 path = "integration_tests/two_expect_pred_failures.rs"

googletest/integration_tests/integration_tests.rs

@@ -481,6 +481,14 @@ mod tests {
         )
     }
 
+    #[cfg(feature = "anyhow")]
+    #[google_test]
+    fn test_can_return_anyhow_generated_error() -> Result<()> {
+        let output = run_external_process_in_tests_directory("test_returning_anyhow_error")?;
+
+        verify_that!(output, contains_substring("Error from Anyhow"))
+    }
+
     fn run_external_process_in_tests_directory(name: &'static str) -> Result<String> {
         let mut command = run_external_process(name);
         let std::process::Output { stdout, .. } = command.output()?;

googletest/integration_tests/test_returning_anyhow_error.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.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::{IntoTestResult, Result};
+
+    #[test]
+    fn should_fail_due_to_error_in_subroutine() -> Result<()> {
+        returns_anyhow_error().into_test_result()?;
+        Ok(())
+    }
+
+    fn returns_anyhow_error() -> std::result::Result<(), anyhow::Error> {
+        Err(anyhow::anyhow!("Error from Anyhow"))
+    }
+}

googletest/src/lib.rs

@@ -416,3 +416,41 @@ impl<T> GoogleTestSupport for std::result::Result<T, TestAssertionFailure> {
         self
     }
 }
+
+/// Provides an extension method for converting an arbitrary type into a
+/// [`Result`].
+///
+/// A type can implement this trait to provide an easy way to return immediately
+/// from a test in conjunction with the `?` operator. This is useful for
+/// [`Result`][std::result::Result] types whose `Result::Err` variant does not
+/// implement [`std::error::Error`].
+///
+/// There is an implementation of this trait for [`anyhow::Error`] (which does
+/// not implement `std::error::Error`) when the `anyhow` feature is enabled.
+/// Importing this trait allows one to easily map [`anyhow::Error`] to a test
+/// failure:
+///
+/// ```
+/// #[test]
+/// fn should_work() -> Result<()> {
+///     let value = something_which_can_fail().into_test_result()?;
+///     ...
+/// }
+///
+/// fn something_which_can_fail() -> anyhow::Result<...> { ... }
+/// ```
+pub trait IntoTestResult<T> {
+    /// Converts this instance into a [`Result`].
+    ///
+    /// Typically, the `Self` type is itself a [`std::result::Result`]. This
+    /// method should then map the `Err` variant to a [`TestAssertionFailure`]
+    /// and leave the `Ok` variant unchanged.
+    fn into_test_result(self) -> Result<T>;
+}
+
+#[cfg(feature = "anyhow")]
+impl<T> IntoTestResult<T> for std::result::Result<T, anyhow::Error> {
+    fn into_test_result(self) -> std::result::Result<T, TestAssertionFailure> {
+        self.map_err(|e| TestAssertionFailure::create(format!("{e}")))
+    }
+}

run_integration_tests.sh

@@ -38,6 +38,7 @@ INTEGRATION_TEST_BINARIES=(
   "non_fatal_failure_in_subroutine"
   "simple_assertion_failure"
   "simple_assertion_failure_with_assert_that"
+  "test_returning_anyhow_error"
   "two_expect_pred_failures"
   "two_expect_that_failures"
   "two_non_fatal_failures"
@@ -47,6 +48,6 @@ INTEGRATION_TEST_BINARIES=(
 
 cargo build
 for binary in ${INTEGRATION_TEST_BINARIES[@]}; do
-  cargo rustc -p googletest --bin $binary --features indoc,rstest -- --test
+  cargo rustc -p googletest --bin $binary --features anyhow,indoc,rstest -- --test
 done
 ./target/debug/integration_tests