How to build test transactions

[feliwir]

Hey, how can i build a database pool that doesn't commit any operations performed on it? In regular diesel i could do this:

pub type DbConn = PgConnection;
pub type DbPool = r2d2::Pool<ConnectionManager<DbConn>>;

pub fn initialize_test_pool(database_url: &str) -> Result<DbPool, Box<dyn Error>> {
    let manager = r2d2::ConnectionManager::<DbConn>::new(database_url);
    let pool = r2d2::Pool::builder()
        .test_on_check_out(true)
        .max_size(1)
        .connection_customizer(Box::new(TestCustomizer))
        .build(manager)?;

    Ok(pool)
}

I tried using a ManagerConfig and customize the connection establishing:

pub type DbConn = AsyncPgConnection;
pub type DbPool = Pool<diesel_async::AsyncPgConnection>;


fn establish_test_connection(
    url: &str,
) -> BoxFuture<ConnectionResult<DbConn>> {
    let fut = async {
        DbConn::establish(url)
            .await
            .map_err(|e| ConnectionError::BadConnection(e.to_string()))
    };
    fut.boxed()
}

pub async fn init_test_database(url: &str) -> std::io::Result<DbPool> {
    let conn = establish_connection(url).await?;
    run_migrations(conn).await?;

    let mut config = ManagerConfig::default();
    config.custom_setup = Box::new(establish_test_connection);
    let db_config = AsyncDieselConnectionManager::<DbConn>::new_with_config(url, config);
    let pool = Pool::builder(db_config).build().map_err(|e| {
        error!("Failed to create database connection pool: {}", e);
        std::io::ErrorKind::Other
    })?;

    Ok(pool)
}

However i'm lost how to wrap the connection into a test transaction. Does someone have a solution for this kind of problem?
Thanks a lot

[weiznich]

You need to do just call AsyncConnection::begin_test_transaction in your establish_test_connection

The TestCustomizer does nothing else internally.

That written I'm open to accept a PR that adds a similar construct to the pools provided by diesel-async to make this more discoverable.

[feliwir]

The issue is that my API performs a pool.get() inside each endpoint, as suggested by: https://actix.rs/docs/databases/

I'd need to define a transaction that lives as long as the pool. So all pool.get invocations use the same transaction.

[weiznich]

I suggest to take a look at the linked code. That is exactly doing that, although with axum and plain diesel. The general idea just remains the same so the solution is in there.

[feliwir]

Are you sure that you linked the correct file? I am not seeing anything related to transactions in there or any of the other files in that folder

[weiznich]

Yes I'm reasonably sure that this is a correct example for a test that shares them same connection with the same test-transaction through several requests of that connection from the pool. Obviously that requires some setup code and so on, but that's all in the linked example repo. There are also slides corresponding to this workshop on my web page. I do not have the capacity to pull it out in detail for you in my free time, so you are on your own there to understand how that example works and how to adopt that to your code base.

[feliwir]

Thank you, i figured it out. The code was commented out, since the sample uses a SQLite memory database