If I pause tokio's clock, acquiring a connection from the pool always times out. How can I best work around this?

[inklesspen]

Tokio has the pause() function which pauses the clock used by sleep(duration).

If time is paused and the runtime has no work to do, the clock is auto-advanced to the next pending timer. This means that Sleep or other timer-backed primitives can cause the runtime to advance the current time when awaited.

This is very useful in tests; suppose I have some logic which writes a row to the DB, waits five minutes, and then performs another action. I don't want my tests to actually spend five minutes sleeping, but due to the auto-advance feature, they can just skip ahead.

Only problem is, pausing the clock seems to make acquiring the connection from the pool always time out, even when there are idle connections in the pool.

        tokio::time::pause();
        println!("size: {}, idle: {}", test_db.db_pool.size(), test_db.db_pool.num_idle());
        let mut conn = assert_ok!(test_db.db_pool.acquire().await);

size: 3, idle: 3

thread 'test_proxy_log_will_eventually_time_out_and_stop_trying_to_update_proxy_id_columns' (40833036) panicked at tests/message_handling_test.rs:525:24:
assertion failed: `assert_ok!(a)`
https://docs.rs/assertables/10.1.0/assertables/macro.assert_ok.html
 a label: `test_db.db_pool.acquire().await`,
 a debug: `Err(PoolTimedOut)`

Setting the acquire_timeout to 24 hours does seem to work around it, but is there a better way to do it?

[inklesspen]

If I wanted a LLM to hallucinate "help" I could have prompted one myself.

[XNinety9]

What times out isn't waiting for a free connection: you have 3 idle ones. It's the health check sqlx runs on an idle connection before handing it out (test_before_acquire, on by default). That check does I/O, so while it's in flight the runtime has nothing else to do, and with a paused clock tokio auto-advances straight to the next timer, which is the acquire timeout. That's also why a 24 h acquire_timeout "fixes" it: it's no longer the next timer.

For tests with a paused clock, turn the check off on the test pool:

let pool = PgPoolOptions::new()
    .test_before_acquire(false)
    // ...
    .connect(&url)
    .await?;

I reproduced it with sqlx 0.8.6 (SQLite in-memory, 3 idle connections, tokio::time::pause() right before acquire()): with the default I get Err(PoolTimedOut), and with test_before_acquire(false) the acquire returns immediately.

One related thing, which I didn't reproduce: since the paused clock can jump far ahead, the pool's own idle_timeout (10 min by default) and max_lifetime (30 min) may close connections during the test, and opening a new one does I/O as well. If you still see timeouts after skipping several minutes, setting idle_timeout(None) and max_lifetime(None) on the test pool avoids that.