Difference between loop + if let Some or while let Some in a tokio::test -> spawn -> spawn_blocking

[Erik-Sovereign]

If someone could be so kind to explain to me, what happens here, this would be highly appreciated. I would also be happy to be just sent documentation I can read myself to understand. I have read the tokio documentation on its website and the Rust async book but maybe I have forgotten an imported part.

1. This works as expected for me and results in a panic

use tokio::sync::mpsc::{self, Receiver, Sender};

#[tokio::main]
async fn main() {
    run_app().await;
}

async fn run_app() -> Result<(), ()> {
    let (worker, sender) = StorageWorker::new();

    let handle = tokio::task::spawn_blocking(|| worker.run().unwrap());

    panic!("hi")
}

pub struct StorageWorker {
    receiver: Receiver<u32>,
}

impl StorageWorker {
    pub fn new() -> (Self, Sender<u32>) {
        let (sender, receiver) = mpsc::channel(20);

        (StorageWorker { receiver }, sender)
    }

    fn run(mut self) -> Result<(), ()> {
        loop {
            if let Some(me) = self.receiver.blocking_recv() {}
        }
        Ok(())
    }
}

2. If I don't run main, but run this test: This never panics and the test never finishes

...
    fn run(mut self) -> Result<(), ()> {
        loop {
            if let Some(me) = self.receiver.blocking_recv() {}
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use tokio::fs;

    use super::*;

    #[tokio::test]
    async fn it_works() {
        tokio::spawn(async {
            run_app().await.unwrap();
        });

        let content = fs::read("test.file").await.unwrap();
    }
}

3. If I don't run main, but run this test: Here the spawned thread panics and the test finishes.

...
    fn run(mut self) -> Result<(), ()> {
        while let Some(me) = self.receiver.blocking_recv() {}
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use tokio::fs;

    use super::*;

    #[tokio::test]
    async fn it_works() {
        tokio::spawn(async {
            run_app().await.unwrap();
        });

        let content = fs::read("test.file").await.unwrap();
    }
}

If I replace spawn_blocking(|| worker.run().unwrap()); with std::thread::spawn 2. works.
I just don't understand what going on here. Is the loop in 2. blocking forever? Because there is only one thread?
If I write #[tokio::test(flavor = "multi_thread")] 2. does still not work.

[ADD-SP]

The example (1) also hangs forever on my side, see https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=f09245299756bbc0838bcc56ea547342.

The reason example (1) hangs forever is that it shuts down the blocking thread pool. However, the blocking task itself hangs forever, so the shutdown process also hangs forever. See also Runtime::shutdown_background and Runtime::shutdown_timeout.

By default, [tokio::test] uses the current-thread runtime instead of the multi-thread runtime. Since run_app().await never resolves, example (2) also hangs forever.

In example (3), the sender gets dropped due to the panic!, which causes the receiver to close, and finally run_app().await resolves. This is why it can finish.

[Erik-Sovereign]

First of all: You are right, (1) runs forever. It runs and throws a panic

[Erik-Sovereign]

Second: You have helped me tremendously to understand my toy example and the real problem I wrote it for. Thank you.
Especially the dropped sender was englightening. I'm going to read the shutdown documentation. Thx again