Expectations are ignored when mock is moved to an async task

[cortopy]

It seems that when a mock is moved into an async task, expectations may be ignored.

If we have:

trait MyTrait {
    fn foo(&self) {}
}

struct MyOtherStruct<T>
where
    T: MyTrait + Clone + Send + Sync + 'static,
{
    pub clonable: T,
}

impl<T> MyOtherStruct<T>
where
    T: MyTrait + Clone + Send + Sync + 'static,
{
    pub fn new(clonable: T) -> Self {
        Self { clonable }
    }

    pub async fn make_it_disappear(&self) {
        let cloned = self.clonable.clone();
        /// Here cloned will be moved to the task and expectations won't get checked
        tokio::spawn(async move {
            cloned.foo();
        });
    }
}

mock! {
    MyStruct {}

    impl Clone for MyStruct {
        fn clone(&self) -> Self;
    }

    impl MyTrait for MyStruct {
        fn foo(&self) {}
    }
}

And I write this test:

#[tokio::test]
async fn should_fail_count() {
    let mut mock1 = MockMyStruct::new();
    let mut mock2 = MockMyStruct::new();
    mock2.expect_foo().times(2).returning(|| {});
    mock1.expect_clone().return_once(move || mock2);

    let consumer = MyOtherStruct::new(mock1);
    consumer.make_it_disappear().await;
}

The mock acts like it indeed dissapeared, as .times(2) is totally ignored and the test passes even though foo was called only once

Trying more things I've noticed that if I have instead:

pub async fn make_it_disappear(&self) {
    let cloned = self.clonable.clone();
    tokio::spawn(async move {
        cloned.foo();
    }).await.unwrap();
}

the expectations are checked and the test fails.

I'm assuming that since the task was never awaited, expectations weren't checked. However, the test finishes ok and so the mock should be dropped at some point. Could this not be checked?

[asomers]

You guessed correctly that foo was never called because of the lack of await. And mock2 did eventually get dropped, which should've paniced, but nothing ensures that it got dropped before your test returned. I'm guessing that mock2 survived the should_fail_count method, and something in tokio::test caught the panic. If you use a plain #[test] and create your own tokio::runtime::Runtime you might get different results.

[cortopy]

@asomers Thanks for the suggestion but I'm afraid that doesn't work either.

This is what I've tried:

#[test]
fn should_fail_count() {
    use tokio::runtime::Runtime;

    let rt = Runtime::new().unwrap();

    rt.block_on(async {
        let mut mock1 = MockMyStruct::new();
        let mut mock2 = MockMyStruct::new();
        mock2.expect_foo().times(2).returning(|| {});
        mock1.expect_clone().return_once(move || mock2);

        let consumer = MyOtherStruct::new(mock1);
        consumer.make_it_disappear().await;
    });
}

The test is still passing

[asomers]

Try running your test with --nocapture. You'll see that the Mock object does indeed panic when the Runtime gets dropped, but not in the main thread. Tokio is swallowing the panic. I suggest you ask for help in Tokio's discord channel.

[fmobus]

Sorry for the necromancy: @cortopy, were you able to solve this? I am having the exact same problem

[jaques-sam]

Same for me :-(

[jjungo]

I've run into the same issue, and I fixed it by joining the JoinHandle (retrieved from tokio::spawn) at the end of the unit test.

In my case, the Tokio task is spawned in MyOtherStruct::new, which stores the JoinHandle. Then, in the unit test, I can use try_join!(my_other_struct.task_handle);, and any panic will be caught.