# Unit Testing Diesel

**URL:** <https://discourse.diesel.rs/t/unit-testing-diesel/104>\
**Category:** Uncategorized\
**Created:** [July 15, 2019, 6:17pm UTC](https://discourse.diesel.rs/t/unit-testing-diesel/104 "2019-07-15T18:17:53Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![elbart](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.diesel.rs/elbart/32/54_2.png) [@elbart](https://discourse.diesel.rs/u/elbart)\
**Post date:** [July 15, 2019, 6:17pm UTC](https://discourse.diesel.rs/t/unit-testing-diesel/104/1 "2019-07-15T18:17:53Z")

</div>

Hi,

first of all I really appreciate the great work diesel is doing to serve as an ORM in the Rust world. I successfully integrated diesel with r2d2 in actix\_web (1.0).

However I now wanted to start to do testing my handlers… The integration looks currently like this.  
The r2d2 connection pool is created like this and passed to the handler via **.data(pool.clone())**

```
let manager = ConnectionManager::<PgConnection>::new(config.database.url.clone());
let pool = r2d2::Pool::builder()
    .build(manager)
    .expect("Failed to create pool.");

HttpServer::new(move || {
    App::new()
        .data(pool.clone())
        .wrap(Logger::default())
        .wrap(CookieSession::signed(&[0; 32]).name("s10s").secure(false))
        .service(
            web::resource("/register")
                .name("register_user")
                .route(web::post().to_async(register_user)),
        )

```

The **register\_user** function looks like this. I use the **web::block** method from actix\_web to run the diesel stuff in a separate thread pool.

```
pub fn register_user(
    (user_data, pool, _session): (
        Json<rest_schemas::RegisterUserRequest>,
        web::Data<Pool>,
        Session,
    ),
) -> impl Future<Item = Json<rest_schemas::RegisterUserSuccessResponse>, Error = Error> {
    web::block(move || S10User::register(pool, &user_data.email, &user_data.password)).then(|res| {
        match res {
            Ok(user) => Box::new(ok::<_, Error>(Json(
                rest_schemas::RegisterUserSuccessResponse { user },
            ))),
            Err(msg) => Box::new(err::<_, Error>(error::ErrorInternalServerError(msg))),
        }
    })    
}

```

The **S10Register::register** function looks like this:

```
pub fn register(
    pool: web::Data<Pool>,
    email: &S10Email,
    password: &S10Password,
) -> Result<S10User, String> {
    let u = S10User {
        id: Uuid::new_v4(),
        email: email.to_string(),
        password: password.to_string(),
        created_at: Utc::now(),
        updated_at: None,
        deleted_at: None,
        status: S10UserStatus::Active,
    };

    let db_user = NewUser {
        email: u.email.clone(),
        password: u.password.clone(),
        status: S10UserStatus::Active.to_string(),
    };

    let conn: &PgConnection = &pool.get().unwrap();

    diesel::insert_into(user::table)
        .values(&db_user)
        .get_result::<User>(conn)
        .expect("Error saving new user to DB");

    return Ok(u);
}

```

I know of the [begin\_test\_transaction](https://docs.diesel.rs/diesel/connection/trait.Connection.html#method.begin_test_transaction) function which looks like exactly what I need to do, but I do not know how to nicely integrate this.I somehow have to create a new Application with a different connection pool, which uses the test\_connection instead of a real one.

Any help would be appreciated.

Thanks,

Tim