Macro assert_enqueued 

macro_rules! assert_enqueued {
    (1 job, to: $backend:ident, $($tail:tt)*) => { ... };
    ($n:literal jobs, to: $backend:ident, $($tail:tt)*) => { ... };
    (1 job, $($tail:tt)*) => { ... };
    ($n:literal jobs, $($tail:tt)*) => { ... };
    (to: $backend:ident, $($tail:tt)*) => { ... };
    (@global $n:literal $($tail:tt)*) => { ... };
    (@internal 1 to: $backend:ident, $($tail:tt)*) => { ... };
    (@internal $n:literal to: $backend:ident, $($tail:tt)*) => { ... };
    (@query $vec:ident; with_data: $data:expr,) => { ... };
    (@query $vec:ident; with_data: $data:expr $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; with_metadata: $metadata:expr,) => { ... };
    (@query $vec:ident; with_metadata: $metadata:expr $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; tagged_with: $tags:expr,) => { ... };
    (@query $vec:ident; tagged_with: $tags:expr $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; scheduled_at: $scheduled_at:expr,) => { ... };
    (@query $vec:ident; scheduled_at: $scheduled_at:expr $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; scheduled_after: $scheduled_after:expr,) => { ... };
    (@query $vec:ident; scheduled_after: $scheduled_after:expr $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; scheduled_before: $scheduled_before:expr,) => { ... };
    (@query $vec:ident; scheduled_before: $scheduled_before:expr $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; for_executor: $executor:literal,) => { ... };
    (@query $vec:ident; for_executor: $executor:literal $(, $($tail:tt)*)?) => { ... };
    (@query $vec:ident; for_executor: $executor:path,) => { ... };
    (@query $vec:ident; for_executor: $executor:path $(, $($tail:tt)*)?) => { ... };
    ($($tail:tt)*) => { ... };
}

A macro for making assertions about what jobs should have been enqueued.

Facilitates making assertions about what jobs have been enqueued into the backend. Assertions can be based on data, metadata, tags, executor, and scheduled_at.

Example

use rexecutor::backend::memory::InMemoryBackend;
let backend = InMemoryBackend::new().paused();
let scheduled_at = Utc::now() + TimeDelta::minutes(5);

ExampleExecutor::builder()
    .with_data("data".to_owned())
    .with_metadata("metadata".to_owned())
    .with_tags(vec!["tag1", "tag2"])
    .schedule_at(scheduled_at)
    .enqueue_to_backend(&backend)
    .await
    .unwrap();

ExampleExecutor::builder()
    .with_data("data2".to_owned())
    .with_metadata("metadata2".to_owned())
    .with_tags(vec!["tag2", "tag3"])
    .schedule_at(scheduled_at)
    .enqueue_to_backend(&backend)
    .await
    .unwrap();


assert_enqueued!(
    to: backend,
    with_data: "data".to_owned(),
    scheduled_at: scheduled_at,
    for_executor: ExampleExecutor
);

assert_enqueued!(
    1 job,
    to: backend,
    with_metadata: "metadata2".to_owned(),
    scheduled_after: Utc::now(),
    for_executor: ExampleExecutor
);

assert_enqueued!(
    2 jobs,
    to: backend,
    tagged_with: ["tag2"],
    scheduled_before: Utc::now() + TimeDelta::hours(1),
    for_executor: ExampleExecutor
);

Example global backend

When working with the global backend, it is possible to use the macro without stating to which backend the job should have been enqueued.

use rexecutor::backend::memory::InMemoryBackend;

let backend = InMemoryBackend::new().paused();

Rexecutor::new(backend).set_global_backend().unwrap();

ExampleExecutor::builder()
    .with_data("data".to_owned())
    .enqueue()
    .await
    .unwrap();

assert_enqueued!(
    with_data: "data".to_owned(),
    for_executor: ExampleExecutor
);

ExampleExecutor::builder()
    .with_data("data".to_owned())
    .enqueue()
    .await
    .unwrap();

assert_enqueued!(
    2 jobs,
    with_data: "data".to_owned(),
    for_executor: ExampleExecutor
);