use std::future::Future;
use crate::{BackendInfo, CanonicalRealm, ExtractScope, Result};
#[allow(clippy::manual_async_fn)]
pub trait Extractor: Send + Sync {
fn detect(&self) -> impl Future<Output = Result<BackendInfo>> + Send;
fn extract(&self, scope: &ExtractScope) -> impl Future<Output = Result<CanonicalRealm>> + Send;
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::BackendInfo;
use crate::version::Version;
use std::{
future::Future,
pin::pin,
task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
};
fn block_on<F: Future>(fut: F) -> F::Output {
const VTABLE: RawWakerVTable = RawWakerVTable::new(|_| RAW_WAKER, |_| {}, |_| {}, |_| {});
const RAW_WAKER: RawWaker = RawWaker::new(std::ptr::null(), &VTABLE);
let waker = unsafe { Waker::from_raw(RAW_WAKER) };
let mut cx = Context::from_waker(&waker);
let mut fut = pin!(fut);
loop {
match fut.as_mut().poll(&mut cx) {
Poll::Ready(output) => break output,
Poll::Pending => std::thread::yield_now(),
}
}
}
struct Stub {
info: BackendInfo,
}
impl Extractor for Stub {
async fn detect(&self) -> Result<BackendInfo> {
Ok(self.info.clone())
}
async fn extract(&self, _scope: &ExtractScope) -> Result<CanonicalRealm> {
Ok(CanonicalRealm::default())
}
}
fn assert_send_sync<T: Send + Sync>() {}
#[test]
fn extractors_are_send_and_sync() {
assert_send_sync::<Stub>();
}
#[test]
fn extractor_futures_resolve_without_a_runtime() {
let stub = Stub {
info: BackendInfo {
backend: "stub".into(),
detected_version: Version::new(1, 0, 0),
extra: Default::default(),
},
};
let detected = block_on(stub.detect()).unwrap();
assert_eq!(detected.backend, "stub");
let realm = block_on(stub.extract(&ExtractScope::new("test"))).unwrap();
assert!(realm.clients.is_empty());
}
}