add assert_warnings test helper

src/err/mod.rs

@@ -822,6 +822,7 @@ impl_signed_integer!(isize);
 mod tests {
     use super::PyErrState;
     use crate::exceptions::{self, PyTypeError, PyValueError};
+    use crate::tests::common::CatchWarnings;
     use crate::{PyErr, PyTypeInfo, Python};
 
     #[test]
@@ -1019,11 +1020,12 @@ mod tests {
             let warnings = py.import("warnings").unwrap();
             warnings.call_method0("resetwarnings").unwrap();
 
-            // First, test with ignoring the warning
-            warnings
-                .call_method1("simplefilter", ("ignore", cls))
-                .unwrap();
-            PyErr::warn(py, cls, "I am warning you", 0).unwrap();
+            // First, test the warning is emitted
+            assert_warnings!(
+                py,
+                { PyErr::warn(py, cls, "I am warning you", 0).unwrap() },
+                [(exceptions::PyUserWarning, "I am warning you")]
+            );
 
             // Test with raising
             warnings
@@ -1031,17 +1033,18 @@ mod tests {
                 .unwrap();
             PyErr::warn(py, cls, "I am warning you", 0).unwrap_err();
 
-            // Test with explicit module and specific filter
+            // Test with error for an explicit module
             warnings.call_method0("resetwarnings").unwrap();
-            warnings
-                .call_method1("simplefilter", ("ignore", cls))
-                .unwrap();
             warnings
                 .call_method1("filterwarnings", ("error", "", cls, "pyo3test"))
                 .unwrap();
 
-            // This has the wrong module and will not raise
-            PyErr::warn(py, cls, "I am warning you", 0).unwrap();
+            // This has the wrong module and will not raise, just be emitted
+            assert_warnings!(
+                py,
+                { PyErr::warn(py, cls, "I am warning you", 0).unwrap() },
+                [(exceptions::PyUserWarning, "I am warning you")]
+            );
 
             let err =
                 PyErr::warn_explicit(py, cls, "I am warning you", "pyo3test.py", 427, None, None)

src/lib.rs

@@ -386,6 +386,12 @@ pub use {
 #[doc(hidden)]
 pub use inventory; // Re-exported for `#[pyclass]` and `#[pymethods]` with `multiple-pymethods`.
 
+/// Tests and helpers which reside inside PyO3's main library. Declared first so that macros
+/// are available in unit tests.
+#[cfg(test)]
+#[macro_use]
+mod tests;
+
 #[macro_use]
 mod internal_tricks;
 
@@ -447,11 +453,6 @@ pub use pyo3_macros::pyclass;
 #[macro_use]
 mod macros;
 
-/// Test macro hygiene - this is in the crate since we won't have
-/// `pyo3` available in the crate root.
-#[cfg(all(test, feature = "macros"))]
-mod test_hygiene;
-
 #[cfg(feature = "experimental-inspect")]
 pub mod inspect;
 

src/tests/mod.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+pub(crate) mod common {
+    use crate as pyo3;
+    include!("../../tests/common.rs");
+}
+
+/// Test macro hygiene - this is in the crate since we won't have
+/// `pyo3` available in the crate root.
+#[cfg(all(test, feature = "macros"))]
+mod hygiene;

tests/common.rs

@@ -1,93 +1,152 @@
-//! Some common macros for tests
+// the inner mod enables the #![allow(dead_code)] to
+// be applied - `test_utils.rs` uses `include!` to pull in this file
 
-#[cfg(all(feature = "macros", Py_3_8))]
-use pyo3::prelude::*;
+/// Common macros and helpers for tests
+#[allow(dead_code)] // many tests do not use the complete set of functionality offered here
+#[macro_use]
+mod inner {
 
-#[macro_export]
-macro_rules! py_assert {
-    ($py:expr, $($val:ident)+, $assertion:literal) => {
-        pyo3::py_run!($py, $($val)+, concat!("assert ", $assertion))
-    };
-    ($py:expr, *$dict:expr, $assertion:literal) => {
-        pyo3::py_run!($py, *$dict, concat!("assert ", $assertion))
-    };
-}
+    #[allow(unused_imports)] // pulls in `use crate as pyo3` in `test_utils.rs`
+    use super::*;
 
-#[macro_export]
-macro_rules! py_expect_exception {
-    // Case1: idents & no err_msg
-    ($py:expr, $($val:ident)+, $code:expr, $err:ident) => {{
-        use pyo3::types::IntoPyDict;
-        let d = [$((stringify!($val), $val.to_object($py)),)+].into_py_dict($py);
-        py_expect_exception!($py, *d, $code, $err)
-    }};
-    // Case2: dict & no err_msg
-    ($py:expr, *$dict:expr, $code:expr, $err:ident) => {{
-        let res = $py.run($code, None, Some($dict));
-        let err = res.expect_err(&format!("Did not raise {}", stringify!($err)));
-        if !err.matches($py, $py.get_type::<pyo3::exceptions::$err>()) {
-            panic!("Expected {} but got {:?}", stringify!($err), err)
-        }
-        err
-    }};
-    // Case3: idents & err_msg
-    ($py:expr, $($val:ident)+, $code:expr, $err:ident, $err_msg:literal) => {{
-        let err = py_expect_exception!($py, $($val)+, $code, $err);
-        // Suppose that the error message looks like 'TypeError: ~'
-        assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
-        err
-    }};
-    // Case4: dict & err_msg
-    ($py:expr, *$dict:expr, $code:expr, $err:ident, $err_msg:literal) => {{
-        let err = py_expect_exception!($py, *$dict, $code, $err);
-        assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
-        err
-    }};
-}
+    use pyo3::prelude::*;
 
-// sys.unraisablehook not available until Python 3.8
-#[cfg(all(feature = "macros", Py_3_8))]
-#[pyclass]
-pub struct UnraisableCapture {
-    pub capture: Option<(PyErr, PyObject)>,
-    old_hook: Option<PyObject>,
-}
+    use pyo3::types::{IntoPyDict, PyList};
 
-#[cfg(all(feature = "macros", Py_3_8))]
-#[pymethods]
-impl UnraisableCapture {
-    pub fn hook(&mut self, unraisable: &PyAny) {
-        let err = PyErr::from_value(unraisable.getattr("exc_value").unwrap());
-        let instance = unraisable.getattr("object").unwrap();
-        self.capture = Some((err, instance.into()));
+    #[macro_export]
+    macro_rules! py_assert {
+        ($py:expr, $($val:ident)+, $assertion:literal) => {
+            pyo3::py_run!($py, $($val)+, concat!("assert ", $assertion))
+        };
+        ($py:expr, *$dict:expr, $assertion:literal) => {
+            pyo3::py_run!($py, *$dict, concat!("assert ", $assertion))
+        };
     }
-}
 
-#[cfg(all(feature = "macros", Py_3_8))]
-impl UnraisableCapture {
-    pub fn install(py: Python<'_>) -> Py<Self> {
-        let sys = py.import("sys").unwrap();
-        let old_hook = sys.getattr("unraisablehook").unwrap().into();
+    #[macro_export]
+    macro_rules! py_expect_exception {
+        // Case1: idents & no err_msg
+        ($py:expr, $($val:ident)+, $code:expr, $err:ident) => {{
+            use pyo3::types::IntoPyDict;
+            let d = [$((stringify!($val), $val.to_object($py)),)+].into_py_dict($py);
+            py_expect_exception!($py, *d, $code, $err)
+        }};
+        // Case2: dict & no err_msg
+        ($py:expr, *$dict:expr, $code:expr, $err:ident) => {{
+            let res = $py.run($code, None, Some($dict));
+            let err = res.expect_err(&format!("Did not raise {}", stringify!($err)));
+            if !err.matches($py, $py.get_type::<pyo3::exceptions::$err>()) {
+                panic!("Expected {} but got {:?}", stringify!($err), err)
+            }
+            err
+        }};
+        // Case3: idents & err_msg
+        ($py:expr, $($val:ident)+, $code:expr, $err:ident, $err_msg:literal) => {{
+            let err = py_expect_exception!($py, $($val)+, $code, $err);
+            // Suppose that the error message looks like 'TypeError: ~'
+            assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
+            err
+        }};
+        // Case4: dict & err_msg
+        ($py:expr, *$dict:expr, $code:expr, $err:ident, $err_msg:literal) => {{
+            let err = py_expect_exception!($py, *$dict, $code, $err);
+            assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
+            err
+        }};
+    }
 
-        let capture = Py::new(
-            py,
-            UnraisableCapture {
-                capture: None,
-                old_hook: Some(old_hook),
-            },
-        )
-        .unwrap();
+    // sys.unraisablehook not available until Python 3.8
+    #[cfg(all(feature = "macros", Py_3_8))]
+    #[pyclass(crate = "pyo3")]
+    pub struct UnraisableCapture {
+        pub capture: Option<(PyErr, PyObject)>,
+        old_hook: Option<PyObject>,
+    }
 
-        sys.setattr("unraisablehook", capture.getattr(py, "hook").unwrap())
+    #[cfg(all(feature = "macros", Py_3_8))]
+    #[pymethods(crate = "pyo3")]
+    impl UnraisableCapture {
+        pub fn hook(&mut self, unraisable: &PyAny) {
+            let err = PyErr::from_value(unraisable.getattr("exc_value").unwrap());
+            let instance = unraisable.getattr("object").unwrap();
+            self.capture = Some((err, instance.into()));
+        }
+    }
+
+    #[cfg(all(feature = "macros", Py_3_8))]
+    impl UnraisableCapture {
+        pub fn install(py: Python<'_>) -> Py<Self> {
+            let sys = py.import("sys").unwrap();
+            let old_hook = sys.getattr("unraisablehook").unwrap().into();
+
+            let capture = Py::new(
+                py,
+                UnraisableCapture {
+                    capture: None,
+                    old_hook: Some(old_hook),
+                },
+            )
             .unwrap();
 
-        capture
+            sys.setattr("unraisablehook", capture.getattr(py, "hook").unwrap())
+                .unwrap();
+
+            capture
+        }
+
+        pub fn uninstall(&mut self, py: Python<'_>) {
+            let old_hook = self.old_hook.take().unwrap();
+
+            let sys = py.import("sys").unwrap();
+            sys.setattr("unraisablehook", old_hook).unwrap();
+        }
     }
 
-    pub fn uninstall(&mut self, py: Python<'_>) {
-        let old_hook = self.old_hook.take().unwrap();
+    pub struct CatchWarnings<'py> {
+        catch_warnings: &'py PyAny,
+    }
 
-        let sys = py.import("sys").unwrap();
-        sys.setattr("unraisablehook", old_hook).unwrap();
+    impl<'py> CatchWarnings<'py> {
+        pub fn enter<R>(py: Python<'py>, f: impl FnOnce(&PyList) -> PyResult<R>) -> PyResult<R> {
+            let warnings = py.import("warnings")?;
+            let kwargs = [("record", true)].into_py_dict(py);
+            let catch_warnings = warnings.getattr("catch_warnings")?.call((), Some(kwargs))?;
+            let list = catch_warnings.call_method0("__enter__")?.extract()?;
+            let _guard = Self { catch_warnings };
+            f(list)
+        }
+    }
+
+    impl Drop for CatchWarnings<'_> {
+        fn drop(&mut self) {
+            let py = self.catch_warnings.py();
+            self.catch_warnings
+                .call_method1("__exit__", (py.None(), py.None(), py.None()))
+                .unwrap();
+        }
+    }
+
+    #[macro_export]
+    macro_rules! assert_warnings {
+        ($py:expr, $body:expr, [$(($category:ty, $message:literal)),+] $(,)? ) => {{
+            CatchWarnings::enter($py, |w| {
+                $body;
+                let expected_warnings = [$((<$category>::type_object($py), $message)),+];
+                assert_eq!(w.len(), expected_warnings.len());
+                for (warning, (category, message)) in w.iter().zip(expected_warnings) {
+
+                    assert!(warning.getattr("category").unwrap().is(category));
+                    assert_eq!(
+                        warning.getattr("message").unwrap().str().unwrap().to_string_lossy(),
+                        message
+                    );
+                }
+
+                Ok(())
+            })
+            .unwrap();
+        }};
     }
 }
+
+pub use inner::*;