Added support for generic runtimes

Author: Andrew J Westlake

pytests/test_tokio_asyncio.rs

@@ -15,20 +15,11 @@ use pyo3_asyncio::{
     tokio::testing::{new_sync_test, test_main},
 };
 
-lazy_static! {
-    static ref CURRENT_THREAD_RUNTIME: Runtime = {
-        Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("Couldn't build the runtime")
-    };
-}
-
 #[pyfunction]
 fn sleep_for(py: Python, secs: &PyAny) -> PyResult<PyObject> {
     let secs = secs.extract()?;
 
-    pyo3_asyncio::tokio::into_coroutine(py, &CURRENT_THREAD_RUNTIME, async move {
+    pyo3_asyncio::tokio::into_coroutine(py, async move {
         tokio::time::sleep(Duration::from_secs(secs)).await;
         Python::with_gil(|py| Ok(py.None()))
     })
@@ -83,13 +74,8 @@ fn test_async_sleep<'p>(
 }
 
 fn main() {
-    thread::spawn(|| {
-        CURRENT_THREAD_RUNTIME.block_on(pending::<()>());
-    });
-
     test_main(
         "PyO3 Asyncio Test Suite",
-        &CURRENT_THREAD_RUNTIME,
         vec![
             Test::new_async(
                 "test_async_sleep".into(),

src/async_std.rs

@@ -1,94 +1,35 @@
-//! # PyO3 Asyncio Testing Utilities
-//!
-//! This module provides some utilities for parsing test arguments as well as running and filtering
-//! a sequence of tests.
-//!
-//! As mentioned [here](crate#pythons-event-loop), PyO3 Asyncio tests cannot use the default test
-//! harness since it doesn't allow Python to gain control over the main thread. Instead, we have to
-//! provide our own test harness in order to create integration tests.
-//!
-//! ## Creating A PyO3 Asyncio Integration Test
-//!
-//! ### Main Test File
-//! First, we need to create the test's main file. Although these tests are considered integration
-//! tests, we cannot put them in the `tests` directory since that is a special directory owned by
-//! Cargo. Instead, we put our tests in a `pytests` directory, although the name `pytests` is just
-//! a convention.
-//!
-//! `pytests/test_example.rs`
-//! ```no_run
-//! fn main() {
-//!
-//! }
-//! ```
-//!
-//! ### Test Manifest Entry
-//! Next, we need to add our test file to the Cargo manifest. Add the following section to your
-//! `Cargo.toml`
-//!
-//! ```toml
-//! [[test]]
-//! name = "test_example"
-//! path = "pytests/test_example.rs"
-//! harness = false
-//! ```
-//!
-//! At this point you should be able to run the test via `cargo test`
-//!
-//! ### Using the PyO3 Asyncio Test Harness
-//! Now that we've got our test registered with `cargo test`, we can start using the PyO3 Asyncio
-//! test harness.
-//!
-//! In your `Cargo.toml` add the testing feature to `pyo3-asyncio`:
-//! ```toml
-//! pyo3-asyncio = { version = "0.13", features = ["testing", "async-std-runtime"] }
-//! ```
-//!
-//! Now, in your test's main file, call [`async_std::testing::test_main`]:
-//!
-//! ```no_run
-//! fn main() {
-//!     pyo3_asyncio::async_std::testing::test_main("Example Test Suite", vec![]);
-//! }
-//! ```
-//!
-//! ### Adding Tests to the PyO3 Asyncio Test Harness
-//!
-//! ```no_run
-//! use std::{time::Duration, thread};
-//!
-//! use pyo3_asyncio::testing::Test;
-//!
-//! fn main() {
-//!     pyo3_asyncio::async_std::testing::test_main(
-//!         "Example Test Suite",
-//!         vec![
-//!             Test::new_async(
-//!                 "test_async_sleep".into(),
-//!                 async move {
-//!                     async_std::task::sleep(Duration::from_secs(1)).await;
-//!                     Ok(())
-//!                 }
-//!             ),
-//!             pyo3_asyncio::async_std::testing::new_sync_test(
-//!                 "test_sync_sleep".into(),
-//!                 || {
-//!                     thread::sleep(Duration::from_secs(1));
-//!                     Ok(())
-//!                 }
-//!             )
-//!         ]
-//!     );
-//! }
-//! ```
-
 use std::future::Future;
 
 use async_std::task;
 use futures::channel::oneshot;
 use pyo3::prelude::*;
 
-use crate::{get_event_loop, CALL_SOON, CREATE_FUTURE, EXPECT_INIT};
+use crate::generic::{self, JoinError, Runtime};
+
+struct AsyncStdJoinError;
+
+impl JoinError for AsyncStdJoinError {
+    fn is_panic(&self) -> bool {
+        todo!()
+    }
+}
+
+struct AsyncStdRuntime;
+
+impl Runtime for AsyncStdRuntime {
+    type JoinError = AsyncStdJoinError;
+    type JoinHandle = task::JoinHandle<Result<(), AsyncStdJoinError>>;
+
+    fn spawn<F>(fut: F) -> Self::JoinHandle
+    where
+        F: Future<Output = ()> + Send + 'static,
+    {
+        task::spawn(async move {
+            fut.await;
+            Ok(())
+        })
+    }
+}
 
 /// Run the event loop until the given Future completes
 ///
@@ -107,17 +48,11 @@ use crate::{get_event_loop, CALL_SOON, CREATE_FUTURE, EXPECT_INIT};
 /// # use std::time::Duration;
 /// #
 /// # use pyo3::prelude::*;
-/// # use tokio::runtime::{Builder, Runtime};
-/// #
-/// # let runtime = Builder::new_current_thread()
-/// #     .enable_all()
-/// #     .build()
-/// #     .expect("Couldn't build the runtime");
 /// #
 /// # Python::with_gil(|py| {
 /// # pyo3_asyncio::with_runtime(py, || {
-/// pyo3_asyncio::tokio::run_until_complete(py, &runtime, async move {
-///     tokio::time::sleep(Duration::from_secs(1)).await;
+/// pyo3_asyncio::async_std::run_until_complete(py, async move {
+///     async_std::task::sleep(Duration::from_secs(1)).await;
 ///     Ok(())
 /// })?;
 /// # Ok(())
@@ -132,14 +67,7 @@ pub fn run_until_complete<F>(py: Python, fut: F) -> PyResult<()>
 where
     F: Future<Output = PyResult<()>> + Send + 'static,
 {
-    let coro = into_coroutine(py, async move {
-        fut.await?;
-        Ok(Python::with_gil(|py| py.None()))
-    })?;
-
-    get_event_loop(py).call_method1("run_until_complete", (coro,))?;
-
-    Ok(())
+    generic::run_until_complete::<AsyncStdRuntime, _>(py, fut)
 }
 
 #[pyclass]
@@ -173,27 +101,6 @@ impl PyTaskCompleter {
     }
 }
 
-fn set_result(py: Python, future: &PyAny, result: PyResult<PyObject>) -> PyResult<()> {
-    match result {
-        Ok(val) => {
-            let set_result = future.getattr("set_result")?;
-            CALL_SOON
-                .get()
-                .expect(EXPECT_INIT)
-                .call1(py, (set_result, val))?;
-        }
-        Err(err) => {
-            let set_exception = future.getattr("set_exception")?;
-            CALL_SOON
-                .get()
-                .expect(EXPECT_INIT)
-                .call1(py, (set_exception, err))?;
-        }
-    }
-
-    Ok(())
-}
-
 fn dump_err(py: Python<'_>) -> impl FnOnce(PyErr) + '_ {
     move |e| {
         // We can't display Python exceptions via std::fmt::Display,
@@ -213,25 +120,14 @@ fn dump_err(py: Python<'_>) -> impl FnOnce(PyErr) + '_ {
 /// ```no_run
 /// use std::time::Duration;
 ///
-/// use lazy_static::lazy_static;
 /// use pyo3::prelude::*;
-/// use tokio::runtime::{Builder, Runtime};
-///
-/// lazy_static! {
-///     static ref CURRENT_THREAD_RUNTIME: Runtime = {
-///         Builder::new_current_thread()
-///             .enable_all()
-///             .build()
-///             .expect("Couldn't build the runtime")
-///     };
-/// }
 ///
 /// /// Awaitable sleep function
 /// #[pyfunction]
 /// fn sleep_for(py: Python, secs: &PyAny) -> PyResult<PyObject> {
 ///     let secs = secs.extract()?;
 ///
-///     pyo3_asyncio::tokio::into_coroutine(py, &CURRENT_THREAD_RUNTIME, async move {
+///     pyo3_asyncio::async_std::into_coroutine(py, async move {
 ///         tokio::time::sleep(Duration::from_secs(secs)).await;
 ///         Python::with_gil(|py| Ok(py.None()))
 ///    })
@@ -241,32 +137,96 @@ pub fn into_coroutine<F>(py: Python, fut: F) -> PyResult<PyObject>
 where
     F: Future<Output = PyResult<PyObject>> + Send + 'static,
 {
-    let future_rx = CREATE_FUTURE.get().expect(EXPECT_INIT).call0(py)?;
-    let future_tx1 = future_rx.clone();
-
-    task::spawn(async move {
-        task::spawn(async move {
-            let result = fut.await;
-
-            Python::with_gil(move |py| {
-                if set_result(py, future_tx1.as_ref(py), result)
-                    .map_err(dump_err(py))
-                    .is_err()
-                {
-
-                    // Cancelled
-                }
-            });
-        })
-        .await;
-    });
-
-    Ok(future_rx)
+    generic::into_coroutine::<AsyncStdRuntime, _>(py, fut)
 }
 
 /// <span class="module-item stab portability" style="display: inline; border-radius: 3px; padding: 2px; font-size: 80%; line-height: 1.2;"><code>testing</code></span> Testing Utilities for the async-std runtime.
 #[cfg(feature = "testing")]
 pub mod testing {
+    //! # PyO3 Asyncio Testing Utilities
+    //!
+    //! This module provides some utilities for parsing test arguments as well as running and filtering
+    //! a sequence of tests.
+    //!
+    //! As mentioned [here](crate#pythons-event-loop), PyO3 Asyncio tests cannot use the default test
+    //! harness since it doesn't allow Python to gain control over the main thread. Instead, we have to
+    //! provide our own test harness in order to create integration tests.
+    //!
+    //! ## Creating A PyO3 Asyncio Integration Test
+    //!
+    //! ### Main Test File
+    //! First, we need to create the test's main file. Although these tests are considered integration
+    //! tests, we cannot put them in the `tests` directory since that is a special directory owned by
+    //! Cargo. Instead, we put our tests in a `pytests` directory, although the name `pytests` is just
+    //! a convention.
+    //!
+    //! `pytests/test_example.rs`
+    //! ```no_run
+    //! fn main() {
+    //!
+    //! }
+    //! ```
+    //!
+    //! ### Test Manifest Entry
+    //! Next, we need to add our test file to the Cargo manifest. Add the following section to your
+    //! `Cargo.toml`
+    //!
+    //! ```toml
+    //! [[test]]
+    //! name = "test_example"
+    //! path = "pytests/test_example.rs"
+    //! harness = false
+    //! ```
+    //!
+    //! At this point you should be able to run the test via `cargo test`
+    //!
+    //! ### Using the PyO3 Asyncio Test Harness
+    //! Now that we've got our test registered with `cargo test`, we can start using the PyO3 Asyncio
+    //! test harness.
+    //!
+    //! In your `Cargo.toml` add the testing feature to `pyo3-asyncio`:
+    //! ```toml
+    //! pyo3-asyncio = { version = "0.13", features = ["testing", "async-std-runtime"] }
+    //! ```
+    //!
+    //! Now, in your test's main file, call [`async_std::testing::test_main`]:
+    //!
+    //! ```no_run
+    //! fn main() {
+    //!     pyo3_asyncio::async_std::testing::test_main("Example Test Suite", vec![]);
+    //! }
+    //! ```
+    //!
+    //! ### Adding Tests to the PyO3 Asyncio Test Harness
+    //!
+    //! ```no_run
+    //! use std::{time::Duration, thread};
+    //!
+    //! use pyo3_asyncio::testing::Test;
+    //!
+    //! fn main() {
+    //!     pyo3_asyncio::async_std::testing::test_main(
+    //!         "Example Test Suite",
+    //!         vec![
+    //!             Test::new_async(
+    //!                 "test_async_sleep".into(),
+    //!                 async move {
+    //!                     async_std::task::sleep(Duration::from_secs(1)).await;
+    //!                     Ok(())
+    //!                 }
+    //!             ),
+    //!             pyo3_asyncio::async_std::testing::new_sync_test(
+    //!                 "test_sync_sleep".into(),
+    //!                 || {
+    //!                     thread::sleep(Duration::from_secs(1));
+    //!                     Ok(())
+    //!                 }
+    //!             )
+    //!         ]
+    //!     );
+    //! }
+    //! ```
+
     use async_std::task;
     use pyo3::prelude::*;