Changed uvloop test to no_run in README, added integration tests for uvloop

Author: Andrew J Westlake

Cargo.toml

@@ -83,6 +83,24 @@ path = "pytests/test_tokio_multi_thread_run_forever.rs"
 harness = false
 required-features = ["tokio-runtime", "testing"]
 
+[[test]]
+name = "test_async_std_uvloop"
+path = "pytests/test_async_std_uvloop.rs"
+harness = false
+required-features = ["async-std-runtime", "testing"]
+
+[[test]]
+name = "test_tokio_current_thread_uvloop"
+path = "pytests/test_tokio_current_thread_uvloop.rs"
+harness = false
+required-features = ["tokio-runtime", "testing"]
+
+[[test]]
+name = "test_tokio_multi_thread_uvloop"
+path = "pytests/test_tokio_multi_thread_uvloop.rs"
+harness = false
+required-features = ["tokio-runtime", "testing"]
+
 [dependencies]
 clap = { version = "2.33", optional = true }
 futures = "0.3"

README.md

@@ -482,7 +482,7 @@ pyo3 = "0.14"
 pyo3-asyncio = { version = "0.14", features = ["async-std-runtime"] }
 ```
 
-```rust
+```rust no_run
 //! main.rs
 
 use pyo3::{prelude::*, types::PyType};

pytests/test_async_std_run_forever.rs

@@ -40,7 +40,7 @@ fn main() {
 
         event_loop.call_method0("run_forever")?;
 
-        println!("test test_run_forever ... ok");
+        println!("test test_async_std_run_forever ... ok");
         Ok(())
     })
     .map_err(|e| Python::with_gil(|py| dump_err(py, e)))

pytests/test_async_std_uvloop.rs

@@ -0,0 +1,35 @@
+use pyo3::{prelude::*, types::PyType};
+
+#[cfg(not(target_os = "windows"))]
+fn main() -> PyResult<()> {
+    pyo3::prepare_freethreaded_python();
+
+    Python::with_gil(|py| {
+        let uvloop = py.import("uvloop")?;
+        uvloop.call_method0("install")?;
+
+        // store a reference for the assertion
+        let uvloop = PyObject::from(uvloop);
+
+        pyo3_asyncio::async_std::run(py, async move {
+            // verify that we are on a uvloop.Loop
+            Python::with_gil(|py| -> PyResult<()> {
+                assert!(uvloop
+                    .as_ref(py)
+                    .getattr("Loop")?
+                    .downcast::<PyType>()
+                    .unwrap()
+                    .is_instance(pyo3_asyncio::async_std::get_current_loop(py)?)?);
+                Ok(())
+            })?;
+
+            async_std::task::sleep(std::time::Duration::from_secs(1)).await;
+
+            println!("test test_async_std_uvloop ... ok");
+            Ok(())
+        })
+    })
+}
+
+#[cfg(target_os = "windows")]
+fn main() {}

pytests/test_tokio_current_thread_run_forever.rs

@@ -12,4 +12,5 @@ fn main() {
     });
 
     tokio_run_forever::test_main();
+    println!("test test_tokio_current_thread_run_forever ... ok");
 }

pytests/test_tokio_current_thread_uvloop.rs

@@ -0,0 +1,43 @@
+use pyo3::{prelude::*, types::PyType};
+
+#[cfg(not(target_os = "windows"))]
+fn main() -> PyResult<()> {
+    pyo3::prepare_freethreaded_python();
+
+    let mut builder = tokio::runtime::Builder::new_current_thread();
+    builder.enable_all();
+
+    pyo3_asyncio::tokio::init(builder);
+    std::thread::spawn(move || {
+        pyo3_asyncio::tokio::get_runtime().block_on(futures::future::pending::<()>());
+    });
+
+    Python::with_gil(|py| {
+        let uvloop = py.import("uvloop")?;
+        uvloop.call_method0("install")?;
+
+        // store a reference for the assertion
+        let uvloop = PyObject::from(uvloop);
+
+        pyo3_asyncio::tokio::run(py, async move {
+            // verify that we are on a uvloop.Loop
+            Python::with_gil(|py| -> PyResult<()> {
+                assert!(uvloop
+                    .as_ref(py)
+                    .getattr("Loop")?
+                    .downcast::<PyType>()
+                    .unwrap()
+                    .is_instance(pyo3_asyncio::tokio::get_current_loop(py)?)?);
+                Ok(())
+            })?;
+
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+            println!("test test_tokio_current_thread_uvloop ... ok");
+            Ok(())
+        })
+    })
+}
+
+#[cfg(target_os = "windows")]
+fn main() {}

pytests/test_tokio_multi_thread_run_forever.rs

@@ -3,4 +3,5 @@ mod tokio_run_forever;
 fn main() {
     pyo3::prepare_freethreaded_python();
     tokio_run_forever::test_main();
+    println!("test test_tokio_multi_thread_run_forever ... ok");
 }

pytests/test_tokio_multi_thread_uvloop.rs

@@ -0,0 +1,35 @@
+use pyo3::{prelude::*, types::PyType};
+
+#[cfg(not(target_os = "windows"))]
+fn main() -> PyResult<()> {
+    pyo3::prepare_freethreaded_python();
+
+    Python::with_gil(|py| {
+        let uvloop = py.import("uvloop")?;
+        uvloop.call_method0("install")?;
+
+        // store a reference for the assertion
+        let uvloop = PyObject::from(uvloop);
+
+        pyo3_asyncio::tokio::run(py, async move {
+            // verify that we are on a uvloop.Loop
+            Python::with_gil(|py| -> PyResult<()> {
+                assert!(uvloop
+                    .as_ref(py)
+                    .getattr("Loop")?
+                    .downcast::<PyType>()
+                    .unwrap()
+                    .is_instance(pyo3_asyncio::tokio::get_current_loop(py)?)?);
+                Ok(())
+            })?;
+
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+            println!("test test_tokio_multi_thread_uvloop ... ok");
+            Ok(())
+        })
+    })
+}
+
+#[cfg(target_os = "windows")]
+fn main() {}

pytests/tokio_run_forever/mod.rs

@@ -38,7 +38,6 @@ pub(super) fn test_main() {
 
         event_loop.call_method0("run_forever")?;
 
-        println!("test test_run_forever ... ok");
         Ok(())
     })
     .map_err(|e| Python::with_gil(|py| dump_err(py, e)))