Struct TestWrapper

pub struct TestWrapper<B, Req, Res> {
    pub backend: B,
    pub worker: Worker<Context>,
    /* private fields */
}

A generic backend wrapper that polls and executes jobs

Fields

backend: B

The inner backend

worker: Worker<Context>

The inner worker

Implementations

impl<B, Req, Res, Ctx> TestWrapper<B, Request<Req, Ctx>, Res>

where B: Backend<Request<Req, Ctx>> + Send + Sync + 'static + Clone, Req: Send + 'static, Ctx: Send, B::Stream: Send + 'static + Stream<Item = Result<Option<Request<Req, Ctx>>, Error>> + Unpin, Res: Debug,

A test wrapper to allow you to test without requiring a worker. Important for testing backends and jobs

Example

#[cfg(tests)]
mod tests {
   use crate::{
       error::Error, memory::MemoryStorage, mq::MessageQueue, service_fn::service_fn,
   };

   use super::*;

   async fn is_even(req: usize) -> Result<(), Error> {
       if req % 2 == 0 {
           Ok(())
       } else {
           Err(Error::Abort("Not an even number".to_string()))
       }
   }

   #[tokio::test]
   async fn test_accepts_even() {
       let backend = MemoryStorage::new();
       let (mut tester, poller) = TestWrapper::new_with_service(backend, service_fn(is_even));
       tokio::spawn(poller);
       tester.enqueue(42usize).await.unwrap();
       assert_eq!(tester.size().await.unwrap(), 1);
       let (_, resp) = tester.execute_next().await.unwrap();
       assert_eq!(resp, Ok("()".to_string()));
   }
}

pub fn new_with_service<Svc>( backend: B, service: Svc, ) -> (Self, BoxFuture<'static, ()>)

where Svc::Future: Send, Svc: Send + Sync + Service<Request<Req, Ctx>, Response = Res> + 'static, Req: Send + Sync + 'static, Svc::Response: Send + Sync + 'static, Svc::Error: Send + Sync + Error, Ctx: Send + Sync + 'static, B: Backend<Request<Req, Ctx>> + 'static, B::Layer: Layer<Svc> + Layer<TestEmitService<Svc>>, <B::Layer as Layer<Svc>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send + Sync, B::Stream: Unpin + Send, Res: Send, <<B::Layer as Layer<Svc>>::Service as Service<Request<Req, Ctx>>>::Future: Send, <<B::Layer as Layer<Svc>>::Service as Service<Request<Req, Ctx>>>::Error: Send + Sync + Error, <B::Layer as Layer<TestEmitService<Svc>>>::Service: Service<Request<Req, Ctx>, Response = Res> + Send + Sync, <<B::Layer as Layer<TestEmitService<Svc>>>::Service as Service<Request<Req, Ctx>>>::Future: Send, <<B::Layer as Layer<TestEmitService<Svc>>>::Service as Service<Request<Req, Ctx>>>::Error: Send + Sync + Error,

Build a new instance provided a custom service

pub fn stop(self)

Stop polling

pub async fn execute_next(&mut self) -> Option<(TaskId, Result<String, String>)>

Gets the current state of results

pub fn try_execute_next( &mut self, ) -> Result<Option<(TaskId, Result<String, String>)>, TryRecvError>

Gets the current state of results

Trait Implementations

impl<B: Debug, Req: Debug, Res: Debug> Debug for TestWrapper<B, Req, Res>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B, Req, Res, Ctx> Deref for TestWrapper<B, Request<Req, Ctx>, Res>

where B: Backend<Request<Req, Ctx>>,

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B, Req, Ctx, Res> DerefMut for TestWrapper<B, Request<Req, Ctx>, Res>

where B: Backend<Request<Req, Ctx>>,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.