Testing with a sqlx database

[pbevin]

Is there a standard way to run cucumber tests against a database? Specifically, I am using sqlx, which has a feature for automatically creating and destroying test databases. A database test could look like this:

#[sqlx::test]
async fn basic_test(pool: PgPool) -> sqlx::Result<()> {
    let mut conn = pool.acquire().await?;

    sqlx::query("SELECT * FROM foo")
        .fetch_one(&mut conn)
        .await?;
        
    assert_eq!(foo.get::<String>("bar"), "foobar!");
    
    Ok(())
}

To use this in cucumber, I think I would have to pass the pool or a connection into the World object, but I don't see how to do that. I tried doing this:

struct AnimalWorld {
    pool: Option<Arc<PgPool>>
}

#[sqlx::test]
async fn main(pool: PgPool) -> Result<()> {
    AnimalWorld::cucumber()
        .fail_on_skipped()
        .before(|_feature, _rule, _scenario, world| {
            Box::pin(async {
                world.pool = Some(Arc::new(pool.clone()));
            })
        })
        .run("features")
        .await;

    Ok(())
}

...but that gives me a lifetime error because pool doesn't live long enough, and before I put a lot of thought into fixing it, I figured I should see what the usual way to do this is.

[ilslv]

@pbevin it looks like #[sqlx::test] is suitable only as a substitution for #[test] which isn't applicable in cucumbers use-case. You should see how #[sqlx::test] works by using cargo expand or looking at a source code and basically re-implement this in before and after hooks. All in all this has more to do with how sqlx works, so you might be better of asking over there.

[pbevin]

Thank you so much. The issue I'm having is really about "how can I get a database pool object into the World object?", and from what you're saying, it sounds like before and after hooks are the right way to do that.

[ilslv]

@pbevin alternatively the book also describes a way to use custom World constructors that actually can be async:

TIP: Using Default::default() for constructing a World object may be not enough. In such case a custom constructor may be specified via #[world(init = my_constructor)] attribute.

#[derive(Debug, World)]
// Accepts both sync/async and fallible/infallible functions.
#[world(init = Self::new)] 
pub struct AnimalWorld {
    cat: Cat,
}

impl AnimalWorld {
    fn new() -> Self {
        Self {
            cat: Cat { hungry: true }
        }
    }
}

[pbevin]

Thank you - that made it much easier than I expected! I wrote a quick function to setup a temporary database in sqlx:

use anyhow::Result;
use dotenvy::dotenv;
use sqlx::{
    testing::{TestArgs, TestSupport},
    PgPool, Postgres,
};

pub async fn init_test_pool() -> Result<PgPool> {
    dotenv().ok();
    let args = TestArgs::new("features::main");
    let ctx = Postgres::test_context(&args).await?;
    let pool = ctx.pool_opts.connect_with(ctx.connect_opts).await?;
    sqlx::migrate!().run(&pool).await?;
    Ok(pool)
}

and then in my World, I wrote an async constructor:

pub async fn new() -> Result<Self> {
    let pool = init_test_pool().await?;
    Ok(Self {
        pool,
        cat: Cat { hungry: true }
    })
}

...and this is exactly what I need, because scenarios are isolated from each other because they run against different database schemas.

Thank you very much for cucumber-rust, and for being so helpful answering questions.