diff --git a/src/tests/account_lock.rs b/src/tests/account_lock.rs
index 0e866c6e3de..97516e840c3 100644
--- a/src/tests/account_lock.rs
+++ b/src/tests/account_lock.rs
@@ -7,19 +7,19 @@ const URL: &str = "/api/v1/me";
 const LOCK_REASON: &str = "test lock reason";
 
 fn lock_account(app: &TestApp, user_id: i32, until: Option<NaiveDateTime>) {
-    app.db(|conn| {
-        use crate::schema::users;
-        use diesel::prelude::*;
-
-        diesel::update(users::table)
-            .set((
-                users::account_lock_reason.eq(LOCK_REASON),
-                users::account_lock_until.eq(until),
-            ))
-            .filter(users::id.eq(user_id))
-            .execute(conn)
-            .unwrap();
-    });
+    use crate::schema::users;
+    use diesel::prelude::*;
+
+    let mut conn = app.db_conn();
+
+    diesel::update(users::table)
+        .set((
+            users::account_lock_reason.eq(LOCK_REASON),
+            users::account_lock_until.eq(until),
+        ))
+        .filter(users::id.eq(user_id))
+        .execute(&mut conn)
+        .unwrap();
 }
 
 #[tokio::test(flavor = "multi_thread")]
diff --git a/src/tests/blocked_routes.rs b/src/tests/blocked_routes.rs
index 2034bdc787b..49696995fd9 100644
--- a/src/tests/blocked_routes.rs
+++ b/src/tests/blocked_routes.rs
@@ -10,11 +10,11 @@ async fn test_non_blocked_download_route() {
         })
         .with_user();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.as_model().id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo", user.as_model().id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
     let status = anon
         .get::<()>("/api/v1/crates/foo/1.0.0/download")
@@ -34,11 +34,11 @@ async fn test_blocked_download_route() {
         })
         .with_user();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.as_model().id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo", user.as_model().id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
     let status = anon
         .get::<()>("/api/v1/crates/foo/1.0.0/download")
diff --git a/src/tests/dump_db.rs b/src/tests/dump_db.rs
index a6040e67d54..65e7a5fbf49 100644
--- a/src/tests/dump_db.rs
+++ b/src/tests/dump_db.rs
@@ -17,12 +17,11 @@ static PATH_DATE_RE: LazyLock<Regex> =
 #[tokio::test(flavor = "multi_thread")]
 async fn test_dump_db_job() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("test-crate", token.as_model().user_id).expect_build(conn);
+    CrateBuilder::new("test-crate", token.as_model().user_id).expect_build(&mut conn);
 
-        DumpDb.enqueue(conn).unwrap();
-    });
+    DumpDb.enqueue(&mut conn).unwrap();
 
     app.run_pending_background_jobs().await;
 
diff --git a/src/tests/github_secret_scanning.rs b/src/tests/github_secret_scanning.rs
index f6c6541eab0..3968c200a6b 100644
--- a/src/tests/github_secret_scanning.rs
+++ b/src/tests/github_secret_scanning.rs
@@ -19,28 +19,25 @@ static GITHUB_PUBLIC_KEY_SIGNATURE: &str = "MEUCIFLZzeK++IhS+y276SRk2Pe5LfDrfvTX
 #[tokio::test(flavor = "multi_thread")]
 async fn github_secret_alert_revokes_token() {
     let (app, anon, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
 
     // Ensure that the token currently exists in the database
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_that!(tokens, len(eq(1)));
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_that!(tokens, len(eq(1)));
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     // Set token to expected value in signed request
-    app.db(|conn| {
-        let hashed_token = HashedToken::hash("some_token");
-        diesel::update(api_tokens::table)
-            .set(api_tokens::token.eq(hashed_token))
-            .execute(conn)
-            .unwrap();
-    });
+    let hashed_token = HashedToken::hash("some_token");
+    diesel::update(api_tokens::table)
+        .set(api_tokens::token.eq(hashed_token))
+        .execute(&mut conn)
+        .unwrap();
 
     let mut request = anon.post_request(URL);
     *request.body_mut() = GITHUB_ALERT.into();
@@ -51,18 +48,17 @@ async fn github_secret_alert_revokes_token() {
     assert_json_snapshot!(response.json());
 
     // Ensure that the token was revoked
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_that!(tokens, empty());
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(true))
-            .load(conn));
-        assert_that!(tokens, len(eq(1)));
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_that!(tokens, empty());
+
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(true))
+        .load(&mut conn));
+    assert_that!(tokens, len(eq(1)));
 
     // Ensure exactly one email was sent
     assert_snapshot!(app.emails_snapshot());
@@ -71,31 +67,28 @@ async fn github_secret_alert_revokes_token() {
 #[tokio::test(flavor = "multi_thread")]
 async fn github_secret_alert_for_revoked_token() {
     let (app, anon, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
 
     // Ensure that the token currently exists in the database
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_that!(tokens, len(eq(1)));
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_that!(tokens, len(eq(1)));
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     // Set token to expected value in signed request and revoke it
-    app.db(|conn| {
-        let hashed_token = HashedToken::hash("some_token");
-        diesel::update(api_tokens::table)
-            .set((
-                api_tokens::token.eq(hashed_token),
-                api_tokens::revoked.eq(true),
-            ))
-            .execute(conn)
-            .unwrap();
-    });
+    let hashed_token = HashedToken::hash("some_token");
+    diesel::update(api_tokens::table)
+        .set((
+            api_tokens::token.eq(hashed_token),
+            api_tokens::revoked.eq(true),
+        ))
+        .execute(&mut conn)
+        .unwrap();
 
     let mut request = anon.post_request(URL);
     *request.body_mut() = GITHUB_ALERT.into();
@@ -106,18 +99,17 @@ async fn github_secret_alert_for_revoked_token() {
     assert_json_snapshot!(response.json());
 
     // Ensure that the token is still revoked
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_that!(tokens, empty());
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(true))
-            .load(conn));
-        assert_that!(tokens, len(eq(1)));
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_that!(tokens, empty());
+
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(true))
+        .load(&mut conn));
+    assert_that!(tokens, len(eq(1)));
 
     // Ensure still no emails were sent
     assert_eq!(app.emails().len(), 0);
@@ -126,19 +118,18 @@ async fn github_secret_alert_for_revoked_token() {
 #[tokio::test(flavor = "multi_thread")]
 async fn github_secret_alert_for_unknown_token() {
     let (app, anon, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
 
     // Ensure that the token currently exists in the database
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_that!(tokens, len(eq(1)));
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_that!(tokens, len(eq(1)));
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     let mut request = anon.post_request(URL);
     *request.body_mut() = GITHUB_ALERT.into();
@@ -149,14 +140,12 @@ async fn github_secret_alert_for_unknown_token() {
     assert_json_snapshot!(response.json());
 
     // Ensure that the token was not revoked
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_that!(tokens, len(eq(1)));
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_that!(tokens, len(eq(1)));
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     // Ensure still no emails were sent
     assert_eq!(app.emails().len(), 0);
diff --git a/src/tests/krate/following.rs b/src/tests/krate/following.rs
index f53eb25518f..e6bf6922f4f 100644
--- a/src/tests/krate/following.rs
+++ b/src/tests/krate/following.rs
@@ -33,10 +33,9 @@ async fn test_unauthenticated_requests() {
     const CRATE_NAME: &str = "foo";
 
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(&mut conn);
 
     let response = anon
         .get::<()>(&format!("/api/v1/crates/{CRATE_NAME}/following"))
@@ -62,10 +61,9 @@ async fn test_following() {
     const CRATE_NAME: &str = "foo_following";
 
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(&mut conn);
 
     // Check that initially we are not following the crate yet.
     assert_is_following(CRATE_NAME, false, &user).await;
@@ -119,12 +117,11 @@ async fn test_api_token_auth() {
     const CRATE_NOT_TO_FOLLOW: &str = "another_crate";
 
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let api_token = token.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new(CRATE_TO_FOLLOW, api_token.user_id).expect_build(conn);
-        CrateBuilder::new(CRATE_NOT_TO_FOLLOW, api_token.user_id).expect_build(conn);
-    });
+    CrateBuilder::new(CRATE_TO_FOLLOW, api_token.user_id).expect_build(&mut conn);
+    CrateBuilder::new(CRATE_NOT_TO_FOLLOW, api_token.user_id).expect_build(&mut conn);
 
     follow(CRATE_TO_FOLLOW, &token).await;
 
diff --git a/src/tests/krate/publish/audit_action.rs b/src/tests/krate/publish/audit_action.rs
index 1eb3adbe861..167e3b736f0 100644
--- a/src/tests/krate/publish/audit_action.rs
+++ b/src/tests/krate/publish/audit_action.rs
@@ -8,7 +8,8 @@ async fn publish_records_an_audit_action() {
 
     let (app, anon, _, token) = TestApp::full().with_token();
 
-    app.db(|conn| assert!(VersionOwnerAction::all(conn).unwrap().is_empty()));
+    let mut conn = app.db_conn();
+    assert!(VersionOwnerAction::all(&mut conn).unwrap().is_empty());
 
     // Upload a new crate, putting it in the git index
     let crate_to_publish = PublishBuilder::new("fyk", "1.0.0");
diff --git a/src/tests/krate/publish/auth.rs b/src/tests/krate/publish/auth.rs
index 92d318220ad..f35abd12c97 100644
--- a/src/tests/krate/publish/auth.rs
+++ b/src/tests/krate/publish/auth.rs
@@ -9,6 +9,7 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn new_wrong_token() {
     let (app, anon, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
     // Try to publish without a token
     let crate_to_publish = PublishBuilder::new("foo", "1.0.0");
@@ -17,12 +18,10 @@ async fn new_wrong_token() {
     assert_snapshot!(response.text(), @r###"{"errors":[{"detail":"this action requires authentication"}]}"###);
 
     // Try to publish with the wrong token (by changing the token in the database)
-    app.db(|conn| {
-        diesel::update(api_tokens::table)
-            .set(api_tokens::token.eq(b"bad" as &[u8]))
-            .execute(conn)
-            .unwrap();
-    });
+    diesel::update(api_tokens::table)
+        .set(api_tokens::token.eq(b"bad" as &[u8]))
+        .execute(&mut conn)
+        .unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo", "1.0.0");
     let response = token.publish_crate(crate_to_publish).await;
@@ -35,11 +34,10 @@ async fn new_wrong_token() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_wrong_user() {
     let (app, _, user) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Create the foo_wrong crate with one user
-        CrateBuilder::new("foo_wrong", user.as_model().id).expect_build(conn);
-    });
+    // Create the foo_wrong crate with one user
+    CrateBuilder::new("foo_wrong", user.as_model().id).expect_build(&mut conn);
 
     // Then try to publish with a different user
     let another_user = app.db_new_user("another").db_new_token("bar");
diff --git a/src/tests/krate/publish/basics.rs b/src/tests/krate/publish/basics.rs
index d9f3862ab65..46f2690fe65 100644
--- a/src/tests/krate/publish/basics.rs
+++ b/src/tests/krate/publish/basics.rs
@@ -9,6 +9,7 @@ use insta::{assert_json_snapshot, assert_snapshot};
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate() {
     let (app, _, user) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
     let crate_to_publish = PublishBuilder::new("foo_new", "1.0.0");
     let response = user.publish_crate(crate_to_publish).await;
@@ -29,13 +30,11 @@ async fn new_krate() {
     rss/updates.xml
     "###);
 
-    app.db(|conn| {
-        let email: String = versions_published_by::table
-            .select(versions_published_by::email)
-            .first(conn)
-            .unwrap();
-        assert_eq!(email, "foo@example.com");
-    });
+    let email: String = versions_published_by::table
+        .select(versions_published_by::email)
+        .first(&mut conn)
+        .unwrap();
+    assert_eq!(email, "foo@example.com");
 
     assert_snapshot!(app.emails_snapshot());
 }
@@ -114,13 +113,12 @@ async fn new_krate_twice() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_duplicate_version() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database and then we'll try to publish the same version
-        CrateBuilder::new("foo_dupe", user.as_model().id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    // Insert a crate directly into the database and then we'll try to publish the same version
+    CrateBuilder::new("foo_dupe", user.as_model().id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let crate_to_publish = PublishBuilder::new("foo_dupe", "1.0.0");
     let response = token.publish_crate(crate_to_publish).await;
diff --git a/src/tests/krate/publish/categories.rs b/src/tests/krate/publish/categories.rs
index 6ceff8779ae..4acc4e8dc75 100644
--- a/src/tests/krate/publish/categories.rs
+++ b/src/tests/krate/publish/categories.rs
@@ -8,12 +8,11 @@ use insta::{assert_json_snapshot, assert_snapshot};
 #[tokio::test(flavor = "multi_thread")]
 async fn good_categories() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        new_category("Category 1", "cat1", "Category 1 crates")
-            .create_or_update(conn)
-            .unwrap();
-    });
+    new_category("Category 1", "cat1", "Category 1 crates")
+        .create_or_update(&mut conn)
+        .unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo_good_cat", "1.0.0").category("cat1");
     let response = token.publish_crate(crate_to_publish).await;
diff --git a/src/tests/krate/publish/dependencies.rs b/src/tests/krate/publish/dependencies.rs
index 0a7f66f0815..e1f55c1b1b0 100644
--- a/src/tests/krate/publish/dependencies.rs
+++ b/src/tests/krate/publish/dependencies.rs
@@ -19,11 +19,10 @@ async fn invalid_dependency_name() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_with_renamed_dependency() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("package-name").rename("my-name");
 
@@ -37,11 +36,10 @@ async fn new_with_renamed_dependency() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invalid_dependency_rename() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .publish_crate(
@@ -57,11 +55,10 @@ async fn invalid_dependency_rename() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invalid_dependency_name_starts_with_digit() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .publish_crate(
@@ -77,11 +74,10 @@ async fn invalid_dependency_name_starts_with_digit() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invalid_dependency_name_contains_unicode_chars() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .publish_crate(
@@ -97,11 +93,10 @@ async fn invalid_dependency_name_contains_unicode_chars() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invalid_too_long_dependency_name() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .publish_crate(
@@ -117,11 +112,11 @@ async fn invalid_too_long_dependency_name() {
 #[tokio::test(flavor = "multi_thread")]
 async fn empty_dependency_name() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
+
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
     let response = token
         .publish_crate(
             PublishBuilder::new("new-krate", "1.0.0")
@@ -136,11 +131,10 @@ async fn empty_dependency_name() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_with_underscore_renamed_dependency() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new-krate can depend on it
-        CrateBuilder::new("package-name", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new-krate can depend on it
+    CrateBuilder::new("package-name", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("package-name").rename("_my-name");
 
@@ -156,14 +150,13 @@ async fn new_krate_with_dependency() {
     use crate::tests::routes::crates::versions::dependencies::Deps;
 
     let (app, anon, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new_dep can depend on it
-        // The name choice of `foo-dep` is important! It has the property of
-        // name != canon_crate_name(name) and is a regression test for
-        // https://github.com/rust-lang/crates.io/issues/651
-        CrateBuilder::new("foo-dep", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new_dep can depend on it
+    // The name choice of `foo-dep` is important! It has the property of
+    // name != canon_crate_name(name) and is a regression test for
+    // https://github.com/rust-lang/crates.io/issues/651
+    CrateBuilder::new("foo-dep", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("foo-dep").version_req("1.0.0");
 
@@ -188,14 +181,13 @@ async fn new_krate_with_dependency() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_with_broken_dependency_requirement() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new_dep can depend on it
-        // The name choice of `foo-dep` is important! It has the property of
-        // name != canon_crate_name(name) and is a regression test for
-        // https://github.com/rust-lang/crates.io/issues/651
-        CrateBuilder::new("foo-dep", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new_dep can depend on it
+    // The name choice of `foo-dep` is important! It has the property of
+    // name != canon_crate_name(name) and is a regression test for
+    // https://github.com/rust-lang/crates.io/issues/651
+    CrateBuilder::new("foo-dep", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("foo-dep").version_req("broken");
 
@@ -209,10 +201,9 @@ async fn new_krate_with_broken_dependency_requirement() {
 #[tokio::test(flavor = "multi_thread")]
 async fn reject_new_krate_with_non_exact_dependency() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo-dep", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo-dep", user.as_model().id).expect_build(&mut conn);
 
     // Use non-exact name for the dependency
     let dependency = DependencyBuilder::new("foo_dep");
@@ -228,10 +219,9 @@ async fn reject_new_krate_with_non_exact_dependency() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_crate_allow_empty_alternative_registry_dependency() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo-dep", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo-dep", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("foo-dep").registry("");
     let crate_to_publish = PublishBuilder::new("foo", "1.0.0").dependency(dependency);
@@ -256,11 +246,10 @@ async fn reject_new_crate_with_alternative_registry_dependency() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_with_wildcard_dependency() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that new_wild can depend on it
-        CrateBuilder::new("foo_wild", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that new_wild can depend on it
+    CrateBuilder::new("foo_wild", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("foo_wild").version_req("*");
 
@@ -290,12 +279,11 @@ async fn new_krate_dependency_missing() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_sorts_deps() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert crates directly into the database so that two-deps can depend on it
-        CrateBuilder::new("dep-a", user.as_model().id).expect_build(conn);
-        CrateBuilder::new("dep-b", user.as_model().id).expect_build(conn);
-    });
+    // Insert crates directly into the database so that two-deps can depend on it
+    CrateBuilder::new("dep-a", user.as_model().id).expect_build(&mut conn);
+    CrateBuilder::new("dep-b", user.as_model().id).expect_build(&mut conn);
 
     let dep_a = DependencyBuilder::new("dep-a");
     let dep_b = DependencyBuilder::new("dep-b");
@@ -331,10 +319,10 @@ async fn test_dep_limit() {
         .with_config(|config| config.max_dependencies = 1)
         .with_token();
 
-    app.db(|conn| {
-        CrateBuilder::new("dep-a", user.as_model().id).expect_build(conn);
-        CrateBuilder::new("dep-b", user.as_model().id).expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("dep-a", user.as_model().id).expect_build(&mut conn);
+    CrateBuilder::new("dep-b", user.as_model().id).expect_build(&mut conn);
 
     let crate_to_publish = PublishBuilder::new("foo", "1.0.0")
         .dependency(DependencyBuilder::new("dep-a"))
diff --git a/src/tests/krate/publish/emails.rs b/src/tests/krate/publish/emails.rs
index 80c690b18e0..2186ae317b4 100644
--- a/src/tests/krate/publish/emails.rs
+++ b/src/tests/krate/publish/emails.rs
@@ -9,10 +9,9 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_without_any_email_fails() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        delete(emails::table).execute(conn).unwrap();
-    });
+    delete(emails::table).execute(&mut conn).unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo_no_email", "1.0.0");
 
@@ -26,13 +25,12 @@ async fn new_krate_without_any_email_fails() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_with_unverified_email_fails() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        update(emails::table)
-            .set((emails::verified.eq(false),))
-            .execute(conn)
-            .unwrap();
-    });
+    update(emails::table)
+        .set((emails::verified.eq(false),))
+        .execute(&mut conn)
+        .unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo_unverified_email", "1.0.0");
 
diff --git a/src/tests/krate/publish/features.rs b/src/tests/krate/publish/features.rs
index b36aa2aa3ef..82c9b3925af 100644
--- a/src/tests/krate/publish/features.rs
+++ b/src/tests/krate/publish/features.rs
@@ -7,11 +7,10 @@ use insta::{assert_json_snapshot, assert_snapshot};
 #[tokio::test(flavor = "multi_thread")]
 async fn features_version_2() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Insert a crate directly into the database so that foo_new can depend on it
-        CrateBuilder::new("bar", user.as_model().id).expect_build(conn);
-    });
+    // Insert a crate directly into the database so that foo_new can depend on it
+    CrateBuilder::new("bar", user.as_model().id).expect_build(&mut conn);
 
     let dependency = DependencyBuilder::new("bar");
 
@@ -124,11 +123,11 @@ async fn too_many_features_with_custom_limit() {
         })
         .with_token();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.as_model().id)
-            .max_features(4)
-            .expect_build(conn)
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo", user.as_model().id)
+        .max_features(4)
+        .expect_build(&mut conn);
 
     let publish_builder = PublishBuilder::new("foo", "1.0.0")
         .feature("one", &[])
@@ -181,11 +180,11 @@ async fn too_many_enabled_features_with_custom_limit() {
         })
         .with_token();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.as_model().id)
-            .max_features(4)
-            .expect_build(conn)
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo", user.as_model().id)
+        .max_features(4)
+        .expect_build(&mut conn);
 
     let publish_builder = PublishBuilder::new("foo", "1.0.0")
         .feature("default", &["one", "two", "three", "four", "five"]);
diff --git a/src/tests/krate/publish/max_size.rs b/src/tests/krate/publish/max_size.rs
index 37f7415d883..b5c5cb0c769 100644
--- a/src/tests/krate/publish/max_size.rs
+++ b/src/tests/krate/publish/max_size.rs
@@ -132,12 +132,11 @@ async fn new_krate_too_big() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_krate_too_big_but_whitelisted() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_whitelist", user.as_model().id)
-            .max_upload_size(2_000_000)
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo_whitelist", user.as_model().id)
+        .max_upload_size(2_000_000)
+        .expect_build(&mut conn);
 
     let crate_to_publish = PublishBuilder::new("foo_whitelist", "1.1.0")
         .add_file("foo_whitelist-1.1.0/big", vec![b'a'; 2000]);
diff --git a/src/tests/krate/publish/rate_limit.rs b/src/tests/krate/publish/rate_limit.rs
index 26ede3e84d6..2ee67604111 100644
--- a/src/tests/krate/publish/rate_limit.rs
+++ b/src/tests/krate/publish/rate_limit.rs
@@ -15,20 +15,21 @@ async fn publish_new_crate_ratelimit_hit() {
         .with_rate_limit(LimitedAction::PublishNew, Duration::from_millis(500), 1)
         .with_token();
 
+    let mut conn = app.db_conn();
+
     // Set up the database so it'll think we've massively ratelimited ourselves
-    app.db(|conn| {
-        // Ratelimit bucket should next refill in about a year
-        let far_future = Utc::now().naive_utc() + Duration::from_secs(60 * 60 * 24 * 365);
-        diesel::insert_into(publish_limit_buckets::table)
-            .values((
-                publish_limit_buckets::user_id.eq(token.as_model().user_id),
-                publish_limit_buckets::action.eq(LimitedAction::PublishNew),
-                publish_limit_buckets::tokens.eq(0),
-                publish_limit_buckets::last_refill.eq(far_future),
-            ))
-            .execute(conn)
-            .expect("Failed to set fake ratelimit")
-    });
+
+    // Ratelimit bucket should next refill in about a year
+    let far_future = Utc::now().naive_utc() + Duration::from_secs(60 * 60 * 24 * 365);
+    diesel::insert_into(publish_limit_buckets::table)
+        .values((
+            publish_limit_buckets::user_id.eq(token.as_model().user_id),
+            publish_limit_buckets::action.eq(LimitedAction::PublishNew),
+            publish_limit_buckets::tokens.eq(0),
+            publish_limit_buckets::last_refill.eq(far_future),
+        ))
+        .execute(&mut conn)
+        .expect("Failed to set fake ratelimit");
 
     let crate_to_publish = PublishBuilder::new("rate_limited", "1.0.0");
     token
@@ -48,20 +49,21 @@ async fn publish_new_crate_ratelimit_expires() {
         .with_rate_limit(LimitedAction::PublishNew, Duration::from_millis(500), 1)
         .with_token();
 
+    let mut conn = app.db_conn();
+
     // Set up the database so it'll think we've massively ratelimited ourselves
-    app.db(|conn| {
-        // Ratelimit bucket should next refill right now!
-        let just_now = Utc::now().naive_utc() - Duration::from_millis(500);
-        diesel::insert_into(publish_limit_buckets::table)
-            .values((
-                publish_limit_buckets::user_id.eq(token.as_model().user_id),
-                publish_limit_buckets::action.eq(LimitedAction::PublishNew),
-                publish_limit_buckets::tokens.eq(0),
-                publish_limit_buckets::last_refill.eq(just_now),
-            ))
-            .execute(conn)
-            .expect("Failed to set fake ratelimit")
-    });
+
+    // Ratelimit bucket should next refill right now!
+    let just_now = Utc::now().naive_utc() - Duration::from_millis(500);
+    diesel::insert_into(publish_limit_buckets::table)
+        .values((
+            publish_limit_buckets::user_id.eq(token.as_model().user_id),
+            publish_limit_buckets::action.eq(LimitedAction::PublishNew),
+            publish_limit_buckets::tokens.eq(0),
+            publish_limit_buckets::last_refill.eq(just_now),
+        ))
+        .execute(&mut conn)
+        .expect("Failed to set fake ratelimit");
 
     let crate_to_publish = PublishBuilder::new("rate_limited", "1.0.0");
     token.publish_crate(crate_to_publish).await.good();
@@ -89,18 +91,18 @@ async fn publish_new_crate_override_loosens_ratelimit() {
         )
         .with_token();
 
-    app.db(|conn| {
-        // Add an override so our user gets *2* new tokens (expires, y'know, sometime)
-        diesel::insert_into(publish_rate_overrides::table)
-            .values((
-                publish_rate_overrides::user_id.eq(token.as_model().user_id),
-                publish_rate_overrides::burst.eq(2),
-                publish_rate_overrides::expires_at.eq(None::<NaiveDateTime>),
-                publish_rate_overrides::action.eq(LimitedAction::PublishNew),
-            ))
-            .execute(conn)
-            .expect("Failed to add ratelimit override")
-    });
+    let mut conn = app.db_conn();
+
+    // Add an override so our user gets *2* new tokens (expires, y'know, sometime)
+    diesel::insert_into(publish_rate_overrides::table)
+        .values((
+            publish_rate_overrides::user_id.eq(token.as_model().user_id),
+            publish_rate_overrides::burst.eq(2),
+            publish_rate_overrides::expires_at.eq(None::<NaiveDateTime>),
+            publish_rate_overrides::action.eq(LimitedAction::PublishNew),
+        ))
+        .execute(&mut conn)
+        .expect("Failed to add ratelimit override");
 
     let crate_to_publish = PublishBuilder::new("rate_limited1", "1.0.0");
     token.publish_crate(crate_to_publish).await.good();
@@ -165,19 +167,19 @@ async fn publish_new_crate_expired_override_ignored() {
         )
         .with_token();
 
-    app.db(|conn| {
-        // Add an override so our user gets *2* new tokens (expires, y'know, sometime)
-        let just_now = Utc::now().naive_utc() - Duration::from_secs(1);
-        diesel::insert_into(publish_rate_overrides::table)
-            .values((
-                publish_rate_overrides::user_id.eq(token.as_model().user_id),
-                publish_rate_overrides::burst.eq(2),
-                publish_rate_overrides::expires_at.eq(just_now),
-                publish_rate_overrides::action.eq(LimitedAction::PublishNew),
-            ))
-            .execute(conn)
-            .expect("Failed to add ratelimit override")
-    });
+    let mut conn = app.db_conn();
+
+    // Add an override so our user gets *2* new tokens (expires, y'know, sometime)
+    let just_now = Utc::now().naive_utc() - Duration::from_secs(1);
+    diesel::insert_into(publish_rate_overrides::table)
+        .values((
+            publish_rate_overrides::user_id.eq(token.as_model().user_id),
+            publish_rate_overrides::burst.eq(2),
+            publish_rate_overrides::expires_at.eq(just_now),
+            publish_rate_overrides::action.eq(LimitedAction::PublishNew),
+        ))
+        .execute(&mut conn)
+        .expect("Failed to add ratelimit override");
 
     let crate_to_publish = PublishBuilder::new("rate_limited1", "1.0.0");
     token.publish_crate(crate_to_publish).await.good();
diff --git a/src/tests/krate/publish/readme.rs b/src/tests/krate/publish/readme.rs
index 7fb1a84811c..4baef5f7c0b 100644
--- a/src/tests/krate/publish/readme.rs
+++ b/src/tests/krate/publish/readme.rs
@@ -71,14 +71,13 @@ async fn new_krate_with_readme_and_plus_version() {
 #[tokio::test(flavor = "multi_thread")]
 async fn publish_after_removing_documentation() {
     let (app, anon, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
     // 1. Start with a crate with no documentation
-    app.db(|conn| {
-        CrateBuilder::new("docscrate", user.id)
-            .version("0.2.0")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("docscrate", user.id)
+        .version("0.2.0")
+        .expect_build(&mut conn);
 
     // Verify that crates start without any documentation so the next assertion can *prove*
     // that it was the one that added the documentation
diff --git a/src/tests/krate/publish/similar_names.rs b/src/tests/krate/publish/similar_names.rs
index 564e3b60d11..1b16bd18b04 100644
--- a/src/tests/krate/publish/similar_names.rs
+++ b/src/tests/krate/publish/similar_names.rs
@@ -7,12 +7,11 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn new_crate_similar_name() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("Foo_similar", user.as_model().id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("Foo_similar", user.as_model().id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let crate_to_publish = PublishBuilder::new("foo_similar", "1.1.0");
     let response = token.publish_crate(crate_to_publish).await;
@@ -24,12 +23,11 @@ async fn new_crate_similar_name() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_crate_similar_name_hyphen() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_bar_hyphen", user.as_model().id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo_bar_hyphen", user.as_model().id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let crate_to_publish = PublishBuilder::new("foo-bar-hyphen", "1.1.0");
     let response = token.publish_crate(crate_to_publish).await;
@@ -41,12 +39,11 @@ async fn new_crate_similar_name_hyphen() {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_crate_similar_name_underscore() {
     let (app, _, user, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo-bar-underscore", user.as_model().id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo-bar-underscore", user.as_model().id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let crate_to_publish = PublishBuilder::new("foo_bar_underscore", "1.1.0");
     let response = token.publish_crate(crate_to_publish).await;
diff --git a/src/tests/krate/publish/timestamps.rs b/src/tests/krate/publish/timestamps.rs
index e6392ed42bb..70c6b9b9179 100644
--- a/src/tests/krate/publish/timestamps.rs
+++ b/src/tests/krate/publish/timestamps.rs
@@ -8,16 +8,15 @@ async fn uploading_new_version_touches_crate() {
     use diesel::{ExpressionMethods, RunQueryDsl};
 
     let (app, _, user) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
     let crate_to_publish = PublishBuilder::new("foo_versions_updated_at", "1.0.0");
     user.publish_crate(crate_to_publish).await.good();
 
-    app.db(|conn| {
-        diesel::update(crates::table)
-            .set(crates::updated_at.eq(crates::updated_at - 1.hour()))
-            .execute(conn)
-            .unwrap();
-    });
+    diesel::update(crates::table)
+        .set(crates::updated_at.eq(crates::updated_at - 1.hour()))
+        .execute(&mut conn)
+        .unwrap();
 
     let json: CrateResponse = user.show_crate("foo_versions_updated_at").await;
     let updated_at_before = json.krate.updated_at;
diff --git a/src/tests/krate/yanking.rs b/src/tests/krate/yanking.rs
index 854f2bb0b3d..3d1680ffe33 100644
--- a/src/tests/krate/yanking.rs
+++ b/src/tests/krate/yanking.rs
@@ -82,20 +82,21 @@ async fn yank_ratelimit_hit() {
         .with_rate_limit(LimitedAction::YankUnyank, Duration::from_millis(500), 1)
         .with_token();
 
+    let mut conn = app.db_conn();
+
     // Set up the database so it'll think we've massively rate-limited ourselves.
-    app.db(|conn| {
-        // Ratelimit bucket should next refill in about a year
-        let far_future = Utc::now().naive_utc() + Duration::from_secs(60 * 60 * 24 * 365);
-        diesel::insert_into(publish_limit_buckets::table)
-            .values((
-                publish_limit_buckets::user_id.eq(token.as_model().user_id),
-                publish_limit_buckets::action.eq(LimitedAction::YankUnyank),
-                publish_limit_buckets::tokens.eq(0),
-                publish_limit_buckets::last_refill.eq(far_future),
-            ))
-            .execute(conn)
-            .expect("Failed to set fake ratelimit")
-    });
+
+    // Ratelimit bucket should next refill in about a year
+    let far_future = Utc::now().naive_utc() + Duration::from_secs(60 * 60 * 24 * 365);
+    diesel::insert_into(publish_limit_buckets::table)
+        .values((
+            publish_limit_buckets::user_id.eq(token.as_model().user_id),
+            publish_limit_buckets::action.eq(LimitedAction::YankUnyank),
+            publish_limit_buckets::tokens.eq(0),
+            publish_limit_buckets::last_refill.eq(far_future),
+        ))
+        .execute(&mut conn)
+        .expect("Failed to set fake ratelimit");
 
     // Upload a new crate
     let crate_to_publish = PublishBuilder::new("yankable", "1.0.0");
@@ -116,20 +117,21 @@ async fn yank_ratelimit_expires() {
         .with_rate_limit(LimitedAction::YankUnyank, Duration::from_millis(500), 1)
         .with_token();
 
+    let mut conn = app.db_conn();
+
     // Set up the database so it'll think we've massively ratelimited ourselves
-    app.db(|conn| {
-        // Ratelimit bucket should next refill right now!
-        let just_now = Utc::now().naive_utc() - Duration::from_millis(500);
-        diesel::insert_into(publish_limit_buckets::table)
-            .values((
-                publish_limit_buckets::user_id.eq(token.as_model().user_id),
-                publish_limit_buckets::action.eq(LimitedAction::YankUnyank),
-                publish_limit_buckets::tokens.eq(0),
-                publish_limit_buckets::last_refill.eq(just_now),
-            ))
-            .execute(conn)
-            .expect("Failed to set fake ratelimit")
-    });
+
+    // Ratelimit bucket should next refill right now!
+    let just_now = Utc::now().naive_utc() - Duration::from_millis(500);
+    diesel::insert_into(publish_limit_buckets::table)
+        .values((
+            publish_limit_buckets::user_id.eq(token.as_model().user_id),
+            publish_limit_buckets::action.eq(LimitedAction::YankUnyank),
+            publish_limit_buckets::tokens.eq(0),
+            publish_limit_buckets::last_refill.eq(just_now),
+        ))
+        .execute(&mut conn)
+        .expect("Failed to set fake ratelimit");
 
     // Upload a new crate
     let crate_to_publish = PublishBuilder::new("yankable", "1.0.0");
diff --git a/src/tests/owners.rs b/src/tests/owners.rs
index c6f5059b8bb..5383e782e5d 100644
--- a/src/tests/owners.rs
+++ b/src/tests/owners.rs
@@ -126,6 +126,7 @@ impl MockAnonymousUser {
 #[tokio::test(flavor = "multi_thread")]
 async fn new_crate_owner() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
     // Create a crate under one user
     let crate_to_publish = PublishBuilder::new("foo_owner", "1.0.0");
@@ -138,7 +139,7 @@ async fn new_crate_owner() {
     assert_snapshot!(app.emails_snapshot());
 
     // accept invitation for user to be added as owner
-    let krate: Crate = app.db(|conn| Crate::by_name("foo_owner").first(conn).unwrap());
+    let krate: Crate = Crate::by_name("foo_owner").first(&mut conn).unwrap();
     user2
         .accept_ownership_invitation("foo_owner", krate.id)
         .await;
@@ -178,10 +179,10 @@ async fn create_and_add_owner(
 #[tokio::test(flavor = "multi_thread")]
 async fn owners_can_remove_self() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let username = &user.as_model().gh_login;
 
-    let krate = app
-        .db(|conn| CrateBuilder::new("owners_selfremove", user.as_model().id).expect_build(conn));
+    let krate = CrateBuilder::new("owners_selfremove", user.as_model().id).expect_build(&mut conn);
 
     // Deleting yourself when you're the only owner isn't allowed.
     let response = token
@@ -211,10 +212,10 @@ async fn owners_can_remove_self() {
 #[tokio::test(flavor = "multi_thread")]
 async fn modify_multiple_owners() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let username = &user.as_model().gh_login;
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("owners_multiple", user.as_model().id).expect_build(conn));
+    let krate = CrateBuilder::new("owners_multiple", user.as_model().id).expect_build(&mut conn);
 
     let user2 = create_and_add_owner(&app, &token, "user2", &krate).await;
     let user3 = create_and_add_owner(&app, &token, "user3", &krate).await;
@@ -227,7 +228,7 @@ async fn modify_multiple_owners() {
         .await;
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
     assert_snapshot!(response.text(), @r#"{"errors":[{"detail":"cannot remove all individual owners of a crate. Team member don't have permission to modify owners, so at least one individual owner is required."}]}"#);
-    assert_eq!(app.db(|conn| krate.owners(conn).unwrap()).len(), 3);
+    assert_eq!(krate.owners(&mut conn).unwrap().len(), 3);
 
     // Deleting two owners at once is allowed.
     let response = token
@@ -235,7 +236,7 @@ async fn modify_multiple_owners() {
         .await;
     assert_eq!(response.status(), StatusCode::OK);
     assert_snapshot!(response.text(), @r#"{"msg":"owners successfully removed","ok":true}"#);
-    assert_eq!(app.db(|conn| krate.owners(conn).unwrap()).len(), 1);
+    assert_eq!(krate.owners(&mut conn).unwrap().len(), 1);
 
     // Adding multiple users fails if one of them already is an owner.
     let response = token
@@ -243,7 +244,7 @@ async fn modify_multiple_owners() {
         .await;
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
     assert_snapshot!(response.text(), @r#"{"errors":[{"detail":"`foo` is already an owner"}]}"#);
-    assert_eq!(app.db(|conn| krate.owners(conn).unwrap()).len(), 1);
+    assert_eq!(krate.owners(&mut conn).unwrap().len(), 1);
 
     // Adding multiple users at once succeeds.
     let response = token
@@ -261,7 +262,7 @@ async fn modify_multiple_owners() {
         .accept_ownership_invitation(&krate.name, krate.id)
         .await;
 
-    assert_eq!(app.db(|conn| krate.owners(conn).unwrap()).len(), 3);
+    assert_eq!(krate.owners(&mut conn).unwrap().len(), 3);
 }
 
 /// Testing the crate ownership between two crates and one team.
@@ -273,19 +274,16 @@ async fn modify_multiple_owners() {
 #[tokio::test(flavor = "multi_thread")]
 async fn check_ownership_two_crates() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let (krate_owned_by_team, team) = app.db(|conn| {
-        let t = new_team("team_foo").create_or_update(conn).unwrap();
-        let krate = CrateBuilder::new("foo", user.id).expect_build(conn);
-        add_team_to_crate(&t, &krate, user, conn).unwrap();
-        (krate, t)
-    });
+    let team = new_team("team_foo").create_or_update(&mut conn).unwrap();
+    let krate_owned_by_team = CrateBuilder::new("foo", user.id).expect_build(&mut conn);
+    add_team_to_crate(&team, &krate_owned_by_team, user, &mut conn).unwrap();
 
     let user2 = app.db_new_user("user_bar");
     let user2 = user2.as_model();
-    let krate_not_owned_by_team =
-        app.db(|conn| CrateBuilder::new("bar", user2.id).expect_build(conn));
+    let krate_not_owned_by_team = CrateBuilder::new("bar", user2.id).expect_build(&mut conn);
 
     let json = anon.search(&format!("user_id={}", user2.id)).await;
     assert_eq!(json.crates[0].name, krate_not_owned_by_team.name);
@@ -307,16 +305,14 @@ async fn check_ownership_two_crates() {
 #[tokio::test(flavor = "multi_thread")]
 async fn check_ownership_one_crate() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let team = app.db(|conn| {
-        let t = new_team("github:test_org:team_sloth")
-            .create_or_update(conn)
-            .unwrap();
-        let krate = CrateBuilder::new("best_crate", user.id).expect_build(conn);
-        add_team_to_crate(&t, &krate, user, conn).unwrap();
-        t
-    });
+    let team = new_team("github:test_org:team_sloth")
+        .create_or_update(&mut conn)
+        .unwrap();
+    let krate = CrateBuilder::new("best_crate", user.id).expect_build(&mut conn);
+    add_team_to_crate(&team, &krate, user, &mut conn).unwrap();
 
     let json: TeamResponse = anon
         .get("/api/v1/crates/best_crate/owner_team")
@@ -338,16 +334,14 @@ async fn check_ownership_one_crate() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_existing_team() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let _team = app.db(|conn| {
-        let t = new_team("github:test_org:bananas")
-            .create_or_update(conn)
-            .unwrap();
-        let krate = CrateBuilder::new("best_crate", user.id).expect_build(conn);
-        add_team_to_crate(&t, &krate, user, conn).unwrap();
-        t
-    });
+    let t = new_team("github:test_org:bananas")
+        .create_or_update(&mut conn)
+        .unwrap();
+    let krate = CrateBuilder::new("best_crate", user.id).expect_build(&mut conn);
+    add_team_to_crate(&t, &krate, user, &mut conn).unwrap();
 
     let ret = token
         .add_named_owner("best_crate", "github:test_org:bananas")
@@ -362,12 +356,11 @@ async fn add_existing_team() {
 #[tokio::test(flavor = "multi_thread")]
 async fn deleted_ownership_isnt_in_owner_user() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let krate = CrateBuilder::new("foo_my_packages", user.id).expect_build(conn);
-        krate.owner_remove(conn, &user.gh_login).unwrap();
-    });
+    let krate = CrateBuilder::new("foo_my_packages", user.id).expect_build(&mut conn);
+    krate.owner_remove(&mut conn, &user.gh_login).unwrap();
 
     let json: UserResponse = anon
         .get("/api/v1/crates/foo_my_packages/owner_user")
@@ -415,9 +408,10 @@ async fn api_token_cannot_list_invitations_v1() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invitations_list_v1() {
     let (app, _, owner, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
 
-    let krate = app.db(|conn| CrateBuilder::new("invited_crate", owner.id).expect_build(conn));
+    let krate = CrateBuilder::new("invited_crate", owner.id).expect_build(&mut conn);
 
     let user = app.db_new_user("invited_user");
     token
@@ -451,12 +445,13 @@ async fn invitations_list_v1() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invitations_list_does_not_include_expired_invites_v1() {
     let (app, _, owner, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
 
     let user = app.db_new_user("invited_user");
 
-    let krate1 = app.db(|conn| CrateBuilder::new("invited_crate_1", owner.id).expect_build(conn));
-    let krate2 = app.db(|conn| CrateBuilder::new("invited_crate_2", owner.id).expect_build(conn));
+    let krate1 = CrateBuilder::new("invited_crate_1", owner.id).expect_build(&mut conn);
+    let krate2 = CrateBuilder::new("invited_crate_2", owner.id).expect_build(&mut conn);
     token
         .add_named_owner("invited_crate_1", "invited_user")
         .await
@@ -497,9 +492,11 @@ async fn invitations_list_does_not_include_expired_invites_v1() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_accept_invitation() {
     let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
     let invited_user = app.db_new_user("user_bar");
-    let krate = app.db(|conn| CrateBuilder::new("accept_invitation", owner.id).expect_build(conn));
+
+    let krate = CrateBuilder::new("accept_invitation", owner.id).expect_build(&mut conn);
 
     // Invite a new owner
     owner_token
@@ -528,9 +525,11 @@ async fn test_accept_invitation() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_decline_invitation() {
     let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
     let invited_user = app.db_new_user("user_bar");
-    let krate = app.db(|conn| CrateBuilder::new("decline_invitation", owner.id).expect_build(conn));
+
+    let krate = CrateBuilder::new("decline_invitation", owner.id).expect_build(&mut conn);
 
     // Invite a new owner
     owner_token
@@ -555,9 +554,12 @@ async fn test_decline_invitation() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_accept_invitation_by_mail() {
     let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
+
     let owner = owner.as_model();
     let invited_user = app.db_new_user("user_bar");
-    let _krate = app.db(|conn| CrateBuilder::new("accept_invitation", owner.id).expect_build(conn));
+
+    CrateBuilder::new("accept_invitation", owner.id).expect_build(&mut conn);
 
     // Invite a new owner
     owner_token
@@ -586,24 +588,26 @@ async fn test_accept_invitation_by_mail() {
 pub fn expire_invitation(app: &TestApp, crate_id: i32) {
     use crate::schema::crate_owner_invitations;
 
-    app.db(|conn| {
-        let expiration = app.as_inner().config.ownership_invitations_expiration_days as i64;
-        let created_at = (Utc::now() - Duration::days(expiration)).naive_utc();
+    let mut conn = app.db_conn();
+
+    let expiration = app.as_inner().config.ownership_invitations_expiration_days as i64;
+    let created_at = (Utc::now() - Duration::days(expiration)).naive_utc();
 
-        diesel::update(crate_owner_invitations::table)
-            .set(crate_owner_invitations::created_at.eq(created_at))
-            .filter(crate_owner_invitations::crate_id.eq(crate_id))
-            .execute(conn)
-            .expect("failed to override the creation time");
-    });
+    diesel::update(crate_owner_invitations::table)
+        .set(crate_owner_invitations::created_at.eq(created_at))
+        .filter(crate_owner_invitations::crate_id.eq(crate_id))
+        .execute(&mut conn)
+        .expect("failed to override the creation time");
 }
 
 #[tokio::test(flavor = "multi_thread")]
 async fn test_accept_expired_invitation() {
     let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
     let invited_user = app.db_new_user("demo_user");
-    let krate = app.db(|conn| CrateBuilder::new("demo_crate", owner.id).expect_build(conn));
+
+    let krate = CrateBuilder::new("demo_crate", owner.id).expect_build(&mut conn);
 
     // Invite a new user
     owner_token
@@ -639,9 +643,11 @@ async fn test_accept_expired_invitation() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_decline_expired_invitation() {
     let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
     let invited_user = app.db_new_user("demo_user");
-    let krate = app.db(|conn| CrateBuilder::new("demo_crate", owner.id).expect_build(conn));
+
+    let krate = CrateBuilder::new("demo_crate", owner.id).expect_build(&mut conn);
 
     // Invite a new user
     owner_token
@@ -665,9 +671,11 @@ async fn test_decline_expired_invitation() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_accept_expired_invitation_by_mail() {
     let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
+
     let owner = owner.as_model();
     let _invited_user = app.db_new_user("demo_user");
-    let krate = app.db(|conn| CrateBuilder::new("demo_crate", owner.id).expect_build(conn));
+    let krate = CrateBuilder::new("demo_crate", owner.id).expect_build(&mut conn);
 
     // Invite a new owner
     owner_token
@@ -708,24 +716,24 @@ async fn inactive_users_dont_get_invitations() {
     use crate::models::NewUser;
 
     let (app, _, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
 
     // An inactive user with gh_id -1 and an active user with a non-negative gh_id both exist
     let invited_gh_login = "user_bar";
     let krate_name = "inactive_test";
 
-    app.db(|conn| {
-        NewUser {
-            gh_id: -1,
-            gh_login: invited_gh_login,
-            name: None,
-            gh_avatar: None,
-            gh_access_token: "some random token",
-        }
-        .create_or_update(None, &app.as_inner().emails, conn)
-        .unwrap();
-        CrateBuilder::new(krate_name, owner.id).expect_build(conn);
-    });
+    NewUser {
+        gh_id: -1,
+        gh_login: invited_gh_login,
+        name: None,
+        gh_avatar: None,
+        gh_access_token: "some random token",
+    }
+    .create_or_update(None, &app.as_inner().emails, &mut conn)
+    .unwrap();
+
+    CrateBuilder::new(krate_name, owner.id).expect_build(&mut conn);
 
     let invited_user = app.db_new_user(invited_gh_login);
 
@@ -741,6 +749,7 @@ async fn inactive_users_dont_get_invitations() {
 #[tokio::test(flavor = "multi_thread")]
 async fn highest_gh_id_is_most_recent_account_we_know_of() {
     let (app, _, owner, owner_token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let owner = owner.as_model();
 
     // An inactive user with a lower gh_id and an active user with a higher gh_id both exist
@@ -752,9 +761,7 @@ async fn highest_gh_id_is_most_recent_account_we_know_of() {
 
     let invited_user = app.db_new_user(invited_gh_login);
 
-    app.db(|conn| {
-        CrateBuilder::new(krate_name, owner.id).expect_build(conn);
-    });
+    CrateBuilder::new(krate_name, owner.id).expect_build(&mut conn);
 
     owner_token
         .add_named_owner(krate_name, "user_bar")
diff --git a/src/tests/pagination.rs b/src/tests/pagination.rs
index a01746e2ab6..40388ed6530 100644
--- a/src/tests/pagination.rs
+++ b/src/tests/pagination.rs
@@ -12,13 +12,13 @@ async fn pagination_blocks_ip_from_cidr_block_list() {
             config.page_offset_cidr_blocklist = vec!["127.0.0.1/24".parse::<IpNetwork>().unwrap()];
         })
         .with_user();
+
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("pagination_links_1", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_2", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_3", user.id).expect_build(conn);
-    });
+    CrateBuilder::new("pagination_links_1", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_2", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_3", user.id).expect_build(&mut conn);
 
     let response = anon
         .get_with_query::<()>("/api/v1/crates", "page=2&per_page=1")
diff --git a/src/tests/read_only_mode.rs b/src/tests/read_only_mode.rs
index 76c86b84418..bb047f94a17 100644
--- a/src/tests/read_only_mode.rs
+++ b/src/tests/read_only_mode.rs
@@ -25,11 +25,11 @@ async fn cannot_hit_endpoint_which_writes_db_in_read_only_mode() {
         })
         .with_token();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_yank_read_only", user.as_model().id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo_yank_read_only", user.as_model().id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let response = token
         .delete::<()>("/api/v1/crates/foo_yank_read_only/1.0.0/yank")
@@ -46,11 +46,11 @@ async fn can_download_crate_in_read_only_mode() {
         })
         .with_user();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_download_read_only", user.as_model().id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo_download_read_only", user.as_model().id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/foo_download_read_only/1.0.0/download")
@@ -58,13 +58,12 @@ async fn can_download_crate_in_read_only_mode() {
     assert_eq!(response.status(), StatusCode::FOUND);
 
     // We're in read only mode so the download should not have been counted
-    app.db(|conn| {
-        use crate::schema::version_downloads;
-        use diesel::dsl::sum;
 
-        let dl_count: Result<Option<i64>, _> = version_downloads::table
-            .select(sum(version_downloads::downloads))
-            .get_result(conn);
-        assert_ok_eq!(dl_count, None);
-    })
+    use crate::schema::version_downloads;
+    use diesel::dsl::sum;
+
+    let dl_count: Result<Option<i64>, _> = version_downloads::table
+        .select(sum(version_downloads::downloads))
+        .get_result(&mut conn);
+    assert_ok_eq!(dl_count, None);
 }
diff --git a/src/tests/routes/categories/get.rs b/src/tests/routes/categories/get.rs
index 03809207985..eea6128266c 100644
--- a/src/tests/routes/categories/get.rs
+++ b/src/tests/routes/categories/get.rs
@@ -8,18 +8,18 @@ use serde_json::Value;
 #[tokio::test(flavor = "multi_thread")]
 async fn show() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
+
     let url = "/api/v1/categories/foo-bar";
 
     // Return not found if a category doesn't exist
     anon.get(url).await.assert_not_found();
 
     // Create a category and a subcategory
-    app.db(|conn| {
-        assert_ok!(new_category("Foo Bar", "foo-bar", "Foo Bar crates").create_or_update(conn));
-        assert_ok!(
-            new_category("Foo Bar::Baz", "foo-bar::baz", "Baz crates").create_or_update(conn)
-        );
-    });
+    assert_ok!(new_category("Foo Bar", "foo-bar", "Foo Bar crates").create_or_update(&mut conn));
+    assert_ok!(
+        new_category("Foo Bar::Baz", "foo-bar::baz", "Baz crates").create_or_update(&mut conn)
+    );
 
     // The category and its subcategories should be in the json
     let json: Value = anon.get(url).await.good();
@@ -38,53 +38,50 @@ async fn update_crate() {
     }
 
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let krate = app.db(|conn| {
-        assert_ok!(new_category("cat1", "cat1", "Category 1 crates").create_or_update(conn));
-        assert_ok!(
-            new_category("Category 2", "category-2", "Category 2 crates").create_or_update(conn)
-        );
+    assert_ok!(new_category("cat1", "cat1", "Category 1 crates").create_or_update(&mut conn));
+    assert_ok!(
+        new_category("Category 2", "category-2", "Category 2 crates").create_or_update(&mut conn)
+    );
 
-        CrateBuilder::new("foo_crate", user.id).expect_build(conn)
-    });
+    let krate = CrateBuilder::new("foo_crate", user.id).expect_build(&mut conn);
 
     // Updating with no categories has no effect
-    app.db(|conn| Category::update_crate(conn, &krate, &[]).unwrap());
+    Category::update_crate(&mut conn, &krate, &[]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Happy path adding one category
-    app.db(|conn| Category::update_crate(conn, &krate, &["cat1"]).unwrap());
+    Category::update_crate(&mut conn, &krate, &["cat1"]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Replacing one category with another
-    app.db(|conn| Category::update_crate(conn, &krate, &["category-2"]).unwrap());
+    Category::update_crate(&mut conn, &krate, &["category-2"]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 1);
 
     // Removing one category
-    app.db(|conn| Category::update_crate(conn, &krate, &[]).unwrap());
+    Category::update_crate(&mut conn, &krate, &[]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Adding 2 categories
-    app.db(|conn| Category::update_crate(conn, &krate, &["cat1", "category-2"]).unwrap());
+    Category::update_crate(&mut conn, &krate, &["cat1", "category-2"]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "category-2").await, 1);
 
     // Removing all categories
-    app.db(|conn| Category::update_crate(conn, &krate, &[]).unwrap());
+    Category::update_crate(&mut conn, &krate, &[]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Attempting to add one valid category and one invalid category
-    app.db(|conn| {
-        let invalid_categories =
-            Category::update_crate(conn, &krate, &["cat1", "catnope"]).unwrap();
-        assert_eq!(invalid_categories, vec!["catnope"]);
-    });
+    let invalid_categories =
+        Category::update_crate(&mut conn, &krate, &["cat1", "catnope"]).unwrap();
+    assert_eq!(invalid_categories, vec!["catnope"]);
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "category-2").await, 0);
 
@@ -95,15 +92,13 @@ async fn update_crate() {
     assert_eq!(json.meta.total, 2);
 
     // Attempting to add a category by display text; must use slug
-    app.db(|conn| Category::update_crate(conn, &krate, &["Category 2"]).unwrap());
+    Category::update_crate(&mut conn, &krate, &["Category 2"]).unwrap();
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Add a category and its subcategory
-    app.db(|conn| {
-        assert_ok!(new_category("cat1::bar", "cat1::bar", "bar crates").create_or_update(conn));
-        Category::update_crate(conn, &krate, &["cat1", "cat1::bar"]).unwrap();
-    });
+    assert_ok!(new_category("cat1::bar", "cat1::bar", "bar crates").create_or_update(&mut conn));
+    Category::update_crate(&mut conn, &krate, &["cat1", "cat1::bar"]).unwrap();
 
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "cat1::bar").await, 1);
diff --git a/src/tests/routes/categories/list.rs b/src/tests/routes/categories/list.rs
index b95eecf4c71..e1263ad2f15 100644
--- a/src/tests/routes/categories/list.rs
+++ b/src/tests/routes/categories/list.rs
@@ -6,20 +6,19 @@ use serde_json::Value;
 #[tokio::test(flavor = "multi_thread")]
 async fn index() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
 
     // List 0 categories if none exist
     let json: Value = anon.get("/api/v1/categories").await.good();
     assert_json_snapshot!(json);
 
     // Create a category and a subcategory
-    app.db(|conn| {
-        new_category("foo", "foo", "Foo crates")
-            .create_or_update(conn)
-            .unwrap();
-        new_category("foo::bar", "foo::bar", "Bar crates")
-            .create_or_update(conn)
-            .unwrap();
-    });
+    new_category("foo", "foo", "Foo crates")
+        .create_or_update(&mut conn)
+        .unwrap();
+    new_category("foo::bar", "foo::bar", "Bar crates")
+        .create_or_update(&mut conn)
+        .unwrap();
 
     // Only the top-level categories should be on the page
     let json: Value = anon.get("/api/v1/categories").await.good();
diff --git a/src/tests/routes/category_slugs/list.rs b/src/tests/routes/category_slugs/list.rs
index 4a3c9e0c56a..9b5c5121b64 100644
--- a/src/tests/routes/category_slugs/list.rs
+++ b/src/tests/routes/category_slugs/list.rs
@@ -6,14 +6,14 @@ use serde_json::Value;
 #[tokio::test(flavor = "multi_thread")]
 async fn category_slugs_returns_all_slugs_in_alphabetical_order() {
     let (app, anon) = TestApp::init().empty();
-    app.db(|conn| {
-        new_category("Foo", "foo", "For crates that foo")
-            .create_or_update(conn)
-            .unwrap();
-        new_category("Bar", "bar", "For crates that bar")
-            .create_or_update(conn)
-            .unwrap();
-    });
+    let mut conn = app.db_conn();
+
+    new_category("Foo", "foo", "For crates that foo")
+        .create_or_update(&mut conn)
+        .unwrap();
+    new_category("Bar", "bar", "For crates that bar")
+        .create_or_update(&mut conn)
+        .unwrap();
 
     let response: Value = anon.get("/api/v1/category_slugs").await.good();
     assert_json_snapshot!(response);
diff --git a/src/tests/routes/crates/downloads.rs b/src/tests/routes/crates/downloads.rs
index dea44131094..e7687b085c1 100644
--- a/src/tests/routes/crates/downloads.rs
+++ b/src/tests/routes/crates/downloads.rs
@@ -64,13 +64,12 @@ pub async fn download(client: &impl RequestHelper, name_and_version: &str) {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_download() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_download", user.id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo_download", user.id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
     // TODO: test the with_json code path
     download(&anon, "foo_download/1.0.0").await;
@@ -79,7 +78,7 @@ async fn test_download() {
     assert_dl_count(&anon, "foo_download/1.0.0", None, 0).await;
     assert_dl_count(&anon, "foo_download", None, 0).await;
 
-    app.db(|conn| save_version_downloads("foo_download", "1.0.0", 1, conn));
+    save_version_downloads("foo_download", "1.0.0", 1, &mut conn);
 
     // Now that the counters are persisted the download counts show up.
     assert_dl_count(&anon, "foo_download/1.0.0", None, 1).await;
@@ -100,12 +99,11 @@ async fn test_download() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_download_with_counting_via_cdn() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.as_model().id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo", user.as_model().id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
     download(&anon, "foo/1.0.0").await;
 
@@ -116,24 +114,21 @@ async fn test_download_with_counting_via_cdn() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_crate_downloads() {
     let (app, anon, cookie) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        let user_id = cookie.as_model().id;
-        CrateBuilder::new("foo", user_id)
-            .version("1.0.0")
-            .version("1.1.0")
-            .expect_build(conn);
-    });
+    let user_id = cookie.as_model().id;
+    CrateBuilder::new("foo", user_id)
+        .version("1.0.0")
+        .version("1.1.0")
+        .expect_build(&mut conn);
 
     download(&anon, "foo/1.0.0").await;
     download(&anon, "foo/1.0.0").await;
     download(&anon, "foo/1.0.0").await;
     download(&anon, "foo/1.1.0").await;
 
-    app.db(|conn| {
-        save_version_downloads("foo", "1.0.0", 3, conn);
-        save_version_downloads("foo", "1.1.0", 1, conn);
-    });
+    save_version_downloads("foo", "1.0.0", 3, &mut conn);
+    save_version_downloads("foo", "1.1.0", 1, &mut conn);
 
     let response = anon.get::<()>("/api/v1/crates/foo/downloads").await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -159,24 +154,21 @@ async fn test_crate_downloads() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_version_downloads() {
     let (app, anon, cookie) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        let user_id = cookie.as_model().id;
-        CrateBuilder::new("foo", user_id)
-            .version("1.0.0")
-            .version("1.1.0")
-            .expect_build(conn);
-    });
+    let user_id = cookie.as_model().id;
+    CrateBuilder::new("foo", user_id)
+        .version("1.0.0")
+        .version("1.1.0")
+        .expect_build(&mut conn);
 
     download(&anon, "foo/1.0.0").await;
     download(&anon, "foo/1.0.0").await;
     download(&anon, "foo/1.0.0").await;
     download(&anon, "foo/1.1.0").await;
 
-    app.db(|conn| {
-        save_version_downloads("foo", "1.0.0", 3, conn);
-        save_version_downloads("foo", "1.1.0", 1, conn);
-    });
+    save_version_downloads("foo", "1.0.0", 3, &mut conn);
+    save_version_downloads("foo", "1.1.0", 1, &mut conn);
 
     let response = anon.get::<()>("/api/v1/crates/foo/1.0.0/downloads").await;
     assert_eq!(response.status(), StatusCode::OK);
diff --git a/src/tests/routes/crates/following.rs b/src/tests/routes/crates/following.rs
index aea4b0241e5..a308f493111 100644
--- a/src/tests/routes/crates/following.rs
+++ b/src/tests/routes/crates/following.rs
@@ -13,13 +13,12 @@ async fn diesel_not_found_results_in_404() {
 #[tokio::test(flavor = "multi_thread")]
 async fn disallow_api_token_auth_for_get_crate_following_status() {
     let (app, _, _, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let api_token = token.as_model();
 
     let a_crate = "a_crate";
 
-    app.db(|conn| {
-        CrateBuilder::new(a_crate, api_token.user_id).expect_build(conn);
-    });
+    CrateBuilder::new(a_crate, api_token.user_id).expect_build(&mut conn);
 
     // Token auth on GET for get following status is disallowed
     token
diff --git a/src/tests/routes/crates/list.rs b/src/tests/routes/crates/list.rs
index 2b754bbe388..2f017395af3 100644
--- a/src/tests/routes/crates/list.rs
+++ b/src/tests/routes/crates/list.rs
@@ -13,17 +13,18 @@ use std::sync::LazyLock;
 #[tokio::test(flavor = "multi_thread")]
 async fn index() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
+
     for json in search_both(&anon, "").await {
         assert_eq!(json.crates.len(), 0);
         assert_eq!(json.meta.total, 0);
     }
 
-    let krate = app.db(|conn| {
-        let u = new_user("foo")
-            .create_or_update(None, &app.as_inner().emails, conn)
-            .unwrap();
-        CrateBuilder::new("fooindex", u.id).expect_build(conn)
-    });
+    let u = new_user("foo")
+        .create_or_update(None, &app.as_inner().emails, &mut conn)
+        .unwrap();
+
+    let krate = CrateBuilder::new("fooindex", u.id).expect_build(&mut conn);
 
     for json in search_both(&anon, "").await {
         assert_eq!(json.crates.len(), 1);
@@ -37,29 +38,27 @@ async fn index() {
 #[allow(clippy::cognitive_complexity)]
 async fn index_queries() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let (krate, krate2) = app.db(|conn| {
-        let krate = CrateBuilder::new("foo_index_queries", user.id)
-            .readme("readme")
-            .description("description")
-            .keyword("kw1")
-            .expect_build(conn);
+    let krate = CrateBuilder::new("foo_index_queries", user.id)
+        .readme("readme")
+        .description("description")
+        .keyword("kw1")
+        .expect_build(&mut conn);
 
-        let krate2 = CrateBuilder::new("BAR_INDEX_QUERIES", user.id)
-            .keyword("KW1")
-            .expect_build(conn);
+    let krate2 = CrateBuilder::new("BAR_INDEX_QUERIES", user.id)
+        .keyword("KW1")
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("foo", user.id)
-            .keyword("kw3")
-            .expect_build(conn);
+    CrateBuilder::new("foo", user.id)
+        .keyword("kw3")
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("two-keywords", user.id)
-            .keyword("kw1")
-            .keyword("kw3")
-            .expect_build(conn);
-        (krate, krate2)
-    });
+    CrateBuilder::new("two-keywords", user.id)
+        .keyword("kw1")
+        .keyword("kw3")
+        .expect_build(&mut conn);
 
     for json in search_both(&anon, "q=baz").await {
         assert_eq!(json.crates.len(), 0);
@@ -153,16 +152,16 @@ async fn index_queries() {
         assert_eq!(json.meta.total, 0);
     }
 
-    app.db(|conn| {
-        new_category("Category 1", "cat1", "Category 1 crates")
-            .create_or_update(conn)
-            .unwrap();
-        new_category("Category 1::Ba'r", "cat1::bar", "Ba'r crates")
-            .create_or_update(conn)
-            .unwrap();
-        Category::update_crate(conn, &krate, &["cat1"]).unwrap();
-        Category::update_crate(conn, &krate2, &["cat1::bar"]).unwrap();
-    });
+    new_category("Category 1", "cat1", "Category 1 crates")
+        .create_or_update(&mut conn)
+        .unwrap();
+
+    new_category("Category 1::Ba'r", "cat1::bar", "Ba'r crates")
+        .create_or_update(&mut conn)
+        .unwrap();
+
+    Category::update_crate(&mut conn, &krate, &["cat1"]).unwrap();
+    Category::update_crate(&mut conn, &krate2, &["cat1::bar"]).unwrap();
 
     for cl in search_both(&anon, "category=cat1").await {
         assert_eq!(cl.crates.len(), 2);
@@ -198,13 +197,14 @@ async fn index_queries() {
 #[tokio::test(flavor = "multi_thread")]
 async fn search_includes_crates_where_name_is_stopword() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("which", user.id).expect_build(conn);
-        CrateBuilder::new("should_be_excluded", user.id)
-            .readme("crate which does things")
-            .expect_build(conn);
-    });
+
+    CrateBuilder::new("which", user.id).expect_build(&mut conn);
+    CrateBuilder::new("should_be_excluded", user.id)
+        .readme("crate which does things")
+        .expect_build(&mut conn);
+
     for json in search_both(&anon, "q=which").await {
         assert_eq!(json.crates.len(), 1);
         assert_eq!(json.meta.total, 1);
@@ -214,25 +214,24 @@ async fn search_includes_crates_where_name_is_stopword() {
 #[tokio::test(flavor = "multi_thread")]
 async fn exact_match_first_on_queries() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_exact", user.id)
-            .description("bar_exact baz_exact")
-            .expect_build(conn);
+    CrateBuilder::new("foo_exact", user.id)
+        .description("bar_exact baz_exact")
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("bar-exact", user.id)
-            .description("foo_exact baz_exact foo-exact baz_exact")
-            .expect_build(conn);
+    CrateBuilder::new("bar-exact", user.id)
+        .description("foo_exact baz_exact foo-exact baz_exact")
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("baz_exact", user.id)
-            .description("foo-exact bar_exact foo-exact bar_exact foo_exact bar_exact")
-            .expect_build(conn);
+    CrateBuilder::new("baz_exact", user.id)
+        .description("foo-exact bar_exact foo-exact bar_exact foo_exact bar_exact")
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("other_exact", user.id)
-            .description("other_exact")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("other_exact", user.id)
+        .description("other_exact")
+        .expect_build(&mut conn);
 
     for json in search_both(&anon, "q=foo-exact").await {
         assert_eq!(json.meta.total, 3);
@@ -260,62 +259,62 @@ async fn exact_match_first_on_queries() {
 #[allow(clippy::cognitive_complexity)]
 async fn index_sorting() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
     // To test that the unique ordering of seed-based pagination is correct, we need to
     // set some columns to the same value.
-    app.db(|conn| {
-        let krate1 = CrateBuilder::new("foo_sort", user.id)
-            .description("bar_sort baz_sort const")
-            .downloads(50)
-            .recent_downloads(50)
-            .expect_build(conn);
-
-        let krate2 = CrateBuilder::new("bar_sort", user.id)
-            .description("foo_sort baz_sort foo_sort baz_sort const")
-            .downloads(3333)
-            .recent_downloads(0)
-            .expect_build(conn);
-
-        let krate3 = CrateBuilder::new("baz_sort", user.id)
-            .description("foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const")
-            .downloads(100_000)
-            .recent_downloads(50)
-            .expect_build(conn);
-
-        let krate4 = CrateBuilder::new("other_sort", user.id)
-            .description("other_sort const")
-            .downloads(100_000)
-            .expect_build(conn);
-
-        // Set the created at column for each crate
-        update(&krate1)
-            .set(crates::created_at.eq(now - 4.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(&krate2)
-            .set(crates::created_at.eq(now - 1.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(crates::table.filter(crates::id.eq_any(vec![krate3.id, krate4.id])))
-            .set(crates::created_at.eq(now - 3.weeks()))
-            .execute(conn)
-            .unwrap();
-
-        // Set the updated at column for each crate
-        update(&krate1)
-            .set(crates::updated_at.eq(now - 3.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(crates::table.filter(crates::id.eq_any(vec![krate2.id, krate3.id])))
-            .set(crates::updated_at.eq(now - 5.days()))
-            .execute(conn)
-            .unwrap();
-        update(&krate4)
-            .set(crates::updated_at.eq(now))
-            .execute(conn)
-            .unwrap();
-    });
+
+    let krate1 = CrateBuilder::new("foo_sort", user.id)
+        .description("bar_sort baz_sort const")
+        .downloads(50)
+        .recent_downloads(50)
+        .expect_build(&mut conn);
+
+    let krate2 = CrateBuilder::new("bar_sort", user.id)
+        .description("foo_sort baz_sort foo_sort baz_sort const")
+        .downloads(3333)
+        .recent_downloads(0)
+        .expect_build(&mut conn);
+
+    let krate3 = CrateBuilder::new("baz_sort", user.id)
+        .description("foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const")
+        .downloads(100_000)
+        .recent_downloads(50)
+        .expect_build(&mut conn);
+
+    let krate4 = CrateBuilder::new("other_sort", user.id)
+        .description("other_sort const")
+        .downloads(100_000)
+        .expect_build(&mut conn);
+
+    // Set the created at column for each crate
+    update(&krate1)
+        .set(crates::created_at.eq(now - 4.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate2)
+        .set(crates::created_at.eq(now - 1.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(crates::table.filter(crates::id.eq_any(vec![krate3.id, krate4.id])))
+        .set(crates::created_at.eq(now - 3.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+
+    // Set the updated at column for each crate
+    update(&krate1)
+        .set(crates::updated_at.eq(now - 3.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(crates::table.filter(crates::id.eq_any(vec![krate2.id, krate3.id])))
+        .set(crates::updated_at.eq(now - 5.days()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate4)
+        .set(crates::updated_at.eq(now))
+        .execute(&mut conn)
+        .unwrap();
 
     // Sort by downloads
     for json in search_both(&anon, "sort=downloads").await {
@@ -480,68 +479,67 @@ async fn index_sorting() {
 #[allow(clippy::cognitive_complexity)]
 async fn ignore_exact_match_on_queries_with_sort() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let krate1 = CrateBuilder::new("foo_sort", user.id)
-            .description("bar_sort baz_sort const")
-            .downloads(50)
-            .recent_downloads(50)
-            .expect_build(conn);
-
-        let krate2 = CrateBuilder::new("bar_sort", user.id)
-            .description("foo_sort baz_sort foo_sort baz_sort const")
-            .downloads(3333)
-            .recent_downloads(0)
-            .expect_build(conn);
-
-        let krate3 = CrateBuilder::new("baz_sort", user.id)
-            .description("foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const")
-            .downloads(100_000)
-            .recent_downloads(10)
-            .expect_build(conn);
-
-        let krate4 = CrateBuilder::new("other_sort", user.id)
-            .description("other_sort const")
-            .downloads(999_999)
-            .expect_build(conn);
-
-        // Set the created at column for each crate
-        update(&krate1)
-            .set(crates::created_at.eq(now - 4.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(&krate2)
-            .set(crates::created_at.eq(now - 1.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(&krate3)
-            .set(crates::created_at.eq(now - 2.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(&krate4)
-            .set(crates::created_at.eq(now - 3.weeks()))
-            .execute(conn)
-            .unwrap();
-
-        // Set the updated at column for each crate
-        update(&krate1)
-            .set(crates::updated_at.eq(now - 3.weeks()))
-            .execute(conn)
-            .unwrap();
-        update(&krate2)
-            .set(crates::updated_at.eq(now - 5.days()))
-            .execute(conn)
-            .unwrap();
-        update(&krate3)
-            .set(crates::updated_at.eq(now - 10.seconds()))
-            .execute(conn)
-            .unwrap();
-        update(&krate4)
-            .set(crates::updated_at.eq(now))
-            .execute(conn)
-            .unwrap();
-    });
+    let krate1 = CrateBuilder::new("foo_sort", user.id)
+        .description("bar_sort baz_sort const")
+        .downloads(50)
+        .recent_downloads(50)
+        .expect_build(&mut conn);
+
+    let krate2 = CrateBuilder::new("bar_sort", user.id)
+        .description("foo_sort baz_sort foo_sort baz_sort const")
+        .downloads(3333)
+        .recent_downloads(0)
+        .expect_build(&mut conn);
+
+    let krate3 = CrateBuilder::new("baz_sort", user.id)
+        .description("foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const")
+        .downloads(100_000)
+        .recent_downloads(10)
+        .expect_build(&mut conn);
+
+    let krate4 = CrateBuilder::new("other_sort", user.id)
+        .description("other_sort const")
+        .downloads(999_999)
+        .expect_build(&mut conn);
+
+    // Set the created at column for each crate
+    update(&krate1)
+        .set(crates::created_at.eq(now - 4.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate2)
+        .set(crates::created_at.eq(now - 1.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate3)
+        .set(crates::created_at.eq(now - 2.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate4)
+        .set(crates::created_at.eq(now - 3.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+
+    // Set the updated at column for each crate
+    update(&krate1)
+        .set(crates::updated_at.eq(now - 3.weeks()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate2)
+        .set(crates::updated_at.eq(now - 5.days()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate3)
+        .set(crates::updated_at.eq(now - 10.seconds()))
+        .execute(&mut conn)
+        .unwrap();
+    update(&krate4)
+        .set(crates::updated_at.eq(now))
+        .execute(&mut conn)
+        .unwrap();
 
     // Sort by downloads, order always the same no matter the crate name query
     for json in search_both(&anon, "q=foo_sort&sort=downloads").await {
@@ -611,14 +609,13 @@ async fn ignore_exact_match_on_queries_with_sort() {
 #[tokio::test(flavor = "multi_thread")]
 async fn multiple_ids() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.id).expect_build(conn);
-        CrateBuilder::new("bar", user.id).expect_build(conn);
-        CrateBuilder::new("baz", user.id).expect_build(conn);
-        CrateBuilder::new("other", user.id).expect_build(conn);
-    });
+    CrateBuilder::new("foo", user.id).expect_build(&mut conn);
+    CrateBuilder::new("bar", user.id).expect_build(&mut conn);
+    CrateBuilder::new("baz", user.id).expect_build(&mut conn);
+    CrateBuilder::new("other", user.id).expect_build(&mut conn);
 
     for json in search_both(
         &anon,
@@ -636,35 +633,36 @@ async fn multiple_ids() {
 #[tokio::test(flavor = "multi_thread")]
 async fn loose_search_order() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let ordered = app.db(|conn| {
-        // exact match should be first
-        let one = CrateBuilder::new("temp", user.id)
-            .readme("readme")
-            .description("description")
-            .keyword("kw1")
-            .expect_build(conn);
-        // temp_udp should match second because of _
-        let two = CrateBuilder::new("temp_utp", user.id)
-            .readme("readme")
-            .description("description")
-            .keyword("kw1")
-            .expect_build(conn);
-        // evalrs should match 3rd because of readme
-        let three = CrateBuilder::new("evalrs", user.id)
-            .readme("evalrs_temp evalrs_temp evalrs_temp")
-            .description("description")
-            .keyword("kw1")
-            .expect_build(conn);
-        // tempfile should appear 4th
-        let four = CrateBuilder::new("tempfile", user.id)
-            .readme("readme")
-            .description("description")
-            .keyword("kw1")
-            .expect_build(conn);
-        vec![one, two, three, four]
-    });
+    // exact match should be first
+    let one = CrateBuilder::new("temp", user.id)
+        .readme("readme")
+        .description("description")
+        .keyword("kw1")
+        .expect_build(&mut conn);
+    // temp_udp should match second because of _
+    let two = CrateBuilder::new("temp_utp", user.id)
+        .readme("readme")
+        .description("description")
+        .keyword("kw1")
+        .expect_build(&mut conn);
+    // evalrs should match 3rd because of readme
+    let three = CrateBuilder::new("evalrs", user.id)
+        .readme("evalrs_temp evalrs_temp evalrs_temp")
+        .description("description")
+        .keyword("kw1")
+        .expect_build(&mut conn);
+    // tempfile should appear 4th
+    let four = CrateBuilder::new("tempfile", user.id)
+        .readme("readme")
+        .description("description")
+        .keyword("kw1")
+        .expect_build(&mut conn);
+
+    let ordered = vec![one, two, three, four];
+
     for search_temp in search_both(&anon, "q=temp").await {
         assert_eq!(search_temp.meta.total, 4);
         assert_eq!(search_temp.crates.len(), 4);
@@ -682,29 +680,28 @@ async fn loose_search_order() {
 #[tokio::test(flavor = "multi_thread")]
 async fn index_include_yanked() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("unyanked", user.id)
-            .version(VersionBuilder::new("1.0.0"))
-            .version(VersionBuilder::new("2.0.0"))
-            .expect_build(conn);
+    CrateBuilder::new("unyanked", user.id)
+        .version(VersionBuilder::new("1.0.0"))
+        .version(VersionBuilder::new("2.0.0"))
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("newest_yanked", user.id)
-            .version(VersionBuilder::new("1.0.0"))
-            .version(VersionBuilder::new("2.0.0").yanked(true))
-            .expect_build(conn);
+    CrateBuilder::new("newest_yanked", user.id)
+        .version(VersionBuilder::new("1.0.0"))
+        .version(VersionBuilder::new("2.0.0").yanked(true))
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("oldest_yanked", user.id)
-            .version(VersionBuilder::new("1.0.0").yanked(true))
-            .version(VersionBuilder::new("2.0.0"))
-            .expect_build(conn);
+    CrateBuilder::new("oldest_yanked", user.id)
+        .version(VersionBuilder::new("1.0.0").yanked(true))
+        .version(VersionBuilder::new("2.0.0"))
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("all_yanked", user.id)
-            .version(VersionBuilder::new("1.0.0").yanked(true))
-            .version(VersionBuilder::new("2.0.0").yanked(true))
-            .expect_build(conn);
-    });
+    CrateBuilder::new("all_yanked", user.id)
+        .version(VersionBuilder::new("1.0.0").yanked(true))
+        .version(VersionBuilder::new("2.0.0").yanked(true))
+        .expect_build(&mut conn);
 
     // Include fully yanked (all versions were yanked) crates
     for json in search_both(&anon, "include_yanked=yes&sort=alphabetical").await {
@@ -727,15 +724,14 @@ async fn index_include_yanked() {
 #[tokio::test(flavor = "multi_thread")]
 async fn yanked_versions_are_not_considered_for_max_version() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_yanked_version", user.id)
-            .description("foo")
-            .version("1.0.0")
-            .version(VersionBuilder::new("1.1.0").yanked(true))
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo_yanked_version", user.id)
+        .description("foo")
+        .version("1.0.0")
+        .version(VersionBuilder::new("1.1.0").yanked(true))
+        .expect_build(&mut conn);
 
     for json in search_both(&anon, "q=foo").await {
         assert_eq!(json.meta.total, 1);
@@ -746,18 +742,17 @@ async fn yanked_versions_are_not_considered_for_max_version() {
 #[tokio::test(flavor = "multi_thread")]
 async fn max_stable_version() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.id)
-            .description("foo")
-            .version("0.3.0")
-            .version("1.0.0")
-            .version(VersionBuilder::new("1.1.0").yanked(true))
-            .version("2.0.0-beta.1")
-            .version("0.3.1")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo", user.id)
+        .description("foo")
+        .version("0.3.0")
+        .version("1.0.0")
+        .version(VersionBuilder::new("1.1.0").yanked(true))
+        .version("2.0.0-beta.1")
+        .version("0.3.1")
+        .expect_build(&mut conn);
 
     for json in search_both(&anon, "q=foo").await {
         assert_eq!(json.meta.total, 1);
@@ -774,22 +769,21 @@ async fn max_stable_version() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_recent_download_count() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        // More than 90 days ago
-        CrateBuilder::new("green_ball", user.id)
-            .description("For fetching")
-            .downloads(10)
-            .recent_downloads(0)
-            .expect_build(conn);
-
-        CrateBuilder::new("sweet_potato_snack", user.id)
-            .description("For when better than usual")
-            .downloads(5)
-            .recent_downloads(2)
-            .expect_build(conn);
-    });
+    // More than 90 days ago
+    CrateBuilder::new("green_ball", user.id)
+        .description("For fetching")
+        .downloads(10)
+        .recent_downloads(0)
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("sweet_potato_snack", user.id)
+        .description("For when better than usual")
+        .downloads(5)
+        .recent_downloads(2)
+        .expect_build(&mut conn);
 
     for json in search_both(&anon, "sort=recent-downloads").await {
         assert_eq!(json.meta.total, 2);
@@ -811,16 +805,15 @@ async fn test_recent_download_count() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_zero_downloads() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        // More than 90 days ago
-        CrateBuilder::new("green_ball", user.id)
-            .description("For fetching")
-            .downloads(0)
-            .recent_downloads(0)
-            .expect_build(conn);
-    });
+    // More than 90 days ago
+    CrateBuilder::new("green_ball", user.id)
+        .description("For fetching")
+        .downloads(0)
+        .recent_downloads(0)
+        .expect_build(&mut conn);
 
     for json in search_both(&anon, "sort=recent-downloads").await {
         assert_eq!(json.meta.total, 1);
@@ -836,26 +829,23 @@ async fn test_zero_downloads() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_default_sort_recent() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let (green_crate, potato_crate) = app.db(|conn| {
-        // More than 90 days ago
-        let green_crate = CrateBuilder::new("green_ball", user.id)
-            .description("For fetching")
-            .keyword("dog")
-            .downloads(10)
-            .recent_downloads(10)
-            .expect_build(conn);
-
-        let potato_crate = CrateBuilder::new("sweet_potato_snack", user.id)
-            .description("For when better than usual")
-            .keyword("dog")
-            .downloads(20)
-            .recent_downloads(0)
-            .expect_build(conn);
-
-        (green_crate, potato_crate)
-    });
+    // More than 90 days ago
+    let green_crate = CrateBuilder::new("green_ball", user.id)
+        .description("For fetching")
+        .keyword("dog")
+        .downloads(10)
+        .recent_downloads(10)
+        .expect_build(&mut conn);
+
+    let potato_crate = CrateBuilder::new("sweet_potato_snack", user.id)
+        .description("For when better than usual")
+        .keyword("dog")
+        .downloads(20)
+        .recent_downloads(0)
+        .expect_build(&mut conn);
 
     // test that index for keywords is sorted by recent_downloads
     // by default
@@ -872,13 +862,11 @@ async fn test_default_sort_recent() {
         assert_eq!(json.crates[1].downloads, 20);
     }
 
-    app.db(|conn| {
-        new_category("Animal", "animal", "animal crates")
-            .create_or_update(conn)
-            .unwrap();
-        Category::update_crate(conn, &green_crate, &["animal"]).unwrap();
-        Category::update_crate(conn, &potato_crate, &["animal"]).unwrap();
-    });
+    new_category("Animal", "animal", "animal crates")
+        .create_or_update(&mut conn)
+        .unwrap();
+    Category::update_crate(&mut conn, &green_crate, &["animal"]).unwrap();
+    Category::update_crate(&mut conn, &potato_crate, &["animal"]).unwrap();
 
     // test that index for categories is sorted by recent_downloads
     // by default
@@ -899,13 +887,12 @@ async fn test_default_sort_recent() {
 #[tokio::test(flavor = "multi_thread")]
 async fn pagination_links_included_if_applicable() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("pagination_links_1", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_2", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_3", user.id).expect_build(conn);
-    });
+    CrateBuilder::new("pagination_links_1", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_2", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_3", user.id).expect_build(&mut conn);
 
     // This uses a filter (`page=n`) to disable seek-based pagination, as seek-based pagination
     // does not return page numbers.
@@ -942,13 +929,12 @@ async fn pagination_links_included_if_applicable() {
 #[tokio::test(flavor = "multi_thread")]
 async fn seek_based_pagination() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("pagination_links_1", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_2", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_3", user.id).expect_build(conn);
-    });
+    CrateBuilder::new("pagination_links_1", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_2", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_3", user.id).expect_build(&mut conn);
 
     let mut url = Some("?per_page=1".to_string());
     let mut results = Vec::new();
@@ -991,13 +977,12 @@ async fn seek_based_pagination() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_pages_work_even_with_seek_based_pagination() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("pagination_links_1", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_2", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_3", user.id).expect_build(conn);
-    });
+    CrateBuilder::new("pagination_links_1", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_2", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_3", user.id).expect_build(&mut conn);
 
     // The next_page returned by the request is seek-based
     let first = anon.search("per_page=1").await;
@@ -1033,13 +1018,12 @@ async fn invalid_seek_parameter() {
 #[tokio::test(flavor = "multi_thread")]
 async fn pagination_parameters_only_accept_integers() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("pagination_links_1", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_2", user.id).expect_build(conn);
-        CrateBuilder::new("pagination_links_3", user.id).expect_build(conn);
-    });
+    CrateBuilder::new("pagination_links_1", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_2", user.id).expect_build(&mut conn);
+    CrateBuilder::new("pagination_links_3", user.id).expect_build(&mut conn);
 
     let response = anon
         .get_with_query::<()>("/api/v1/crates", "page=1&per_page=100%22%EF%BC%8Cexception")
@@ -1057,10 +1041,10 @@ async fn pagination_parameters_only_accept_integers() {
 #[tokio::test(flavor = "multi_thread")]
 async fn crates_by_user_id() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let id = user.as_model().id;
-    app.db(|conn| {
-        CrateBuilder::new("foo_my_packages", id).expect_build(conn);
-    });
+
+    CrateBuilder::new("foo_my_packages", id).expect_build(&mut conn);
 
     for response in search_both_by_user_id(&user, id).await {
         assert_eq!(response.crates.len(), 1);
@@ -1071,12 +1055,11 @@ async fn crates_by_user_id() {
 #[tokio::test(flavor = "multi_thread")]
 async fn crates_by_user_id_not_including_deleted_owners() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let krate = CrateBuilder::new("foo_my_packages", user.id).expect_build(conn);
-        krate.owner_remove(conn, "foo").unwrap();
-    });
+    let krate = CrateBuilder::new("foo_my_packages", user.id).expect_build(&mut conn);
+    krate.owner_remove(&mut conn, "foo").unwrap();
 
     for response in search_both_by_user_id(&anon, user.id).await {
         assert_eq!(response.crates.len(), 0);
diff --git a/src/tests/routes/crates/owners/add.rs b/src/tests/routes/crates/owners/add.rs
index f600e82d735..945506ae411 100644
--- a/src/tests/routes/crates/owners/add.rs
+++ b/src/tests/routes/crates/owners/add.rs
@@ -11,11 +11,10 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_cargo_invite_owners() {
     let (app, _, owner) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
     let new_user = app.db_new_user("cilantro");
-    app.db(|conn| {
-        CrateBuilder::new("guacamole", owner.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("guacamole", owner.as_model().id).expect_build(&mut conn);
 
     #[derive(Serialize)]
     struct OwnerReq {
@@ -51,12 +50,12 @@ async fn test_cargo_invite_owners() {
 #[tokio::test(flavor = "multi_thread")]
 async fn owner_change_via_cookie() {
     let (app, _, cookie) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", cookie.as_model().id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", cookie.as_model().id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -69,12 +68,12 @@ async fn owner_change_via_cookie() {
 #[tokio::test(flavor = "multi_thread")]
 async fn owner_change_via_token() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -89,11 +88,12 @@ async fn owner_change_via_change_owner_token() {
     let (app, _, _, token) =
         TestApp::full().with_scoped_token(None, Some(vec![EndpointScope::ChangeOwners]));
 
+    let mut conn = app.db_conn();
+
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -108,12 +108,12 @@ async fn owner_change_via_change_owner_token_with_matching_crate_scope() {
     let crate_scopes = Some(vec![CrateScope::try_from("foo_crate").unwrap()]);
     let endpoint_scopes = Some(vec![EndpointScope::ChangeOwners]);
     let (app, _, _, token) = TestApp::full().with_scoped_token(crate_scopes, endpoint_scopes);
+    let mut conn = app.db_conn();
 
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -128,12 +128,12 @@ async fn owner_change_via_change_owner_token_with_wrong_crate_scope() {
     let crate_scopes = Some(vec![CrateScope::try_from("bar").unwrap()]);
     let endpoint_scopes = Some(vec![EndpointScope::ChangeOwners]);
     let (app, _, _, token) = TestApp::full().with_scoped_token(crate_scopes, endpoint_scopes);
+    let mut conn = app.db_conn();
 
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -148,11 +148,12 @@ async fn owner_change_via_publish_token() {
     let (app, _, _, token) =
         TestApp::full().with_scoped_token(None, Some(vec![EndpointScope::PublishUpdate]));
 
+    let mut conn = app.db_conn();
+
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", token.as_model().user_id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -165,12 +166,12 @@ async fn owner_change_via_publish_token() {
 #[tokio::test(flavor = "multi_thread")]
 async fn owner_change_without_auth() {
     let (app, anon, cookie) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
     let user2 = app.db_new_user("user-2");
     let user2 = user2.as_model();
 
-    let krate =
-        app.db(|conn| CrateBuilder::new("foo_crate", cookie.as_model().id).expect_build(conn));
+    let krate = CrateBuilder::new("foo_crate", cookie.as_model().id).expect_build(&mut conn);
 
     let url = format!("/api/v1/crates/{}/owners", krate.name);
     let body = json!({ "owners": [user2.gh_login] });
@@ -183,7 +184,9 @@ async fn owner_change_without_auth() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_owner_change_with_legacy_field() {
     let (app, _, user1) = TestApp::full().with_user();
-    app.db(|conn| CrateBuilder::new("foo", user1.as_model().id).expect_build(conn));
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo", user1.as_model().id).expect_build(&mut conn);
     app.db_new_user("user2");
 
     let input = r#"{"users": ["user2"]}"#;
@@ -197,8 +200,10 @@ async fn test_owner_change_with_legacy_field() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_owner_change_with_invalid_json() {
     let (app, _, user) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
+
     app.db_new_user("bar");
-    app.db(|conn| CrateBuilder::new("foo", user.as_model().id).expect_build(conn));
+    CrateBuilder::new("foo", user.as_model().id).expect_build(&mut conn);
 
     // incomplete input
     let input = r#"{"owners": ["foo", }"#;
@@ -228,8 +233,10 @@ async fn test_owner_change_with_invalid_json() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invite_already_invited_user() {
     let (app, _, _, owner) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
+
     app.db_new_user("invited_user");
-    app.db(|conn| CrateBuilder::new("crate_name", owner.as_model().user_id).expect_build(conn));
+    CrateBuilder::new("crate_name", owner.as_model().user_id).expect_build(&mut conn);
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
@@ -254,9 +261,10 @@ async fn invite_already_invited_user() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invite_with_existing_expired_invite() {
     let (app, _, _, owner) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
+
     app.db_new_user("invited_user");
-    let krate =
-        app.db(|conn| CrateBuilder::new("crate_name", owner.as_model().user_id).expect_build(conn));
+    let krate = CrateBuilder::new("crate_name", owner.as_model().user_id).expect_build(&mut conn);
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
@@ -297,8 +305,9 @@ async fn test_unknown_crate() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_unknown_user() {
     let (app, _, cookie) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| CrateBuilder::new("foo", cookie.as_model().id).expect_build(conn));
+    CrateBuilder::new("foo", cookie.as_model().id).expect_build(&mut conn);
 
     let body = serde_json::to_vec(&json!({ "owners": ["unknown"] })).unwrap();
     let response = cookie.put::<()>("/api/v1/crates/foo/owners", body).await;
@@ -309,8 +318,9 @@ async fn test_unknown_user() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_unknown_team() {
     let (app, _, cookie) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| CrateBuilder::new("foo", cookie.as_model().id).expect_build(conn));
+    CrateBuilder::new("foo", cookie.as_model().id).expect_build(&mut conn);
 
     let body = serde_json::to_vec(&json!({ "owners": ["github:unknown:unknown"] })).unwrap();
     let response = cookie.put::<()>("/api/v1/crates/foo/owners", body).await;
@@ -321,7 +331,9 @@ async fn test_unknown_team() {
 #[tokio::test(flavor = "multi_thread")]
 async fn max_invites_per_request() {
     let (app, _, _, owner) = TestApp::init().with_token();
-    app.db(|conn| CrateBuilder::new("crate_name", owner.as_model().user_id).expect_build(conn));
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("crate_name", owner.as_model().user_id).expect_build(&mut conn);
 
     let usernames = (0..11)
         .map(|i| format!("user_{i}"))
@@ -341,7 +353,9 @@ async fn max_invites_per_request() {
 #[tokio::test(flavor = "multi_thread")]
 async fn no_invite_emails_for_txn_rollback() {
     let (app, _, _, token) = TestApp::init().with_token();
-    app.db(|conn| CrateBuilder::new("crate_name", token.as_model().user_id).expect_build(conn));
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("crate_name", token.as_model().user_id).expect_build(&mut conn);
 
     let mut usernames = (0..9).map(|i| format!("user_{i}")).collect::<Vec<String>>();
 
diff --git a/src/tests/routes/crates/owners/remove.rs b/src/tests/routes/crates/owners/remove.rs
index 3252a4c7981..a24970a48ef 100644
--- a/src/tests/routes/crates/owners/remove.rs
+++ b/src/tests/routes/crates/owners/remove.rs
@@ -6,8 +6,10 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_owner_change_with_invalid_json() {
     let (app, _, user) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
+
     app.db_new_user("bar");
-    app.db(|conn| CrateBuilder::new("foo", user.as_model().id).expect_build(conn));
+    CrateBuilder::new("foo", user.as_model().id).expect_build(&mut conn);
 
     // incomplete input
     let input = r#"{"owners": ["foo", }"#;
@@ -52,8 +54,9 @@ async fn test_unknown_crate() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_unknown_user() {
     let (app, _, cookie) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| CrateBuilder::new("foo", cookie.as_model().id).expect_build(conn));
+    CrateBuilder::new("foo", cookie.as_model().id).expect_build(&mut conn);
 
     let body = serde_json::to_vec(&json!({ "owners": ["unknown"] })).unwrap();
     let response = cookie
@@ -66,8 +69,9 @@ async fn test_unknown_user() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_unknown_team() {
     let (app, _, cookie) = TestApp::full().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| CrateBuilder::new("foo", cookie.as_model().id).expect_build(conn));
+    CrateBuilder::new("foo", cookie.as_model().id).expect_build(&mut conn);
 
     let body = serde_json::to_vec(&json!({ "owners": ["github:unknown:unknown"] })).unwrap();
     let response = cookie
diff --git a/src/tests/routes/crates/read.rs b/src/tests/routes/crates/read.rs
index 01c86f76c09..dcf669f2e70 100644
--- a/src/tests/routes/crates/read.rs
+++ b/src/tests/routes/crates/read.rs
@@ -7,35 +7,32 @@ use insta::{assert_json_snapshot, assert_snapshot};
 #[tokio::test(flavor = "multi_thread")]
 async fn show() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        use crate::schema::versions;
-        use diesel::{update, ExpressionMethods};
-
-        let krate = CrateBuilder::new("foo_show", user.id)
-            .description("description")
-            .documentation("https://example.com")
-            .homepage("http://example.com")
-            .version(VersionBuilder::new("1.0.0"))
-            .version(VersionBuilder::new("0.5.0"))
-            .version(VersionBuilder::new("0.5.1"))
-            .keyword("kw1")
-            .downloads(20)
-            .recent_downloads(10)
-            .expect_build(conn);
-
-        // Make version 1.0.0 mimic a version published before we started recording who published
-        // versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .filter(versions::num.eq("1.0.0"))
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
-
-        krate
-    });
+    use crate::schema::versions;
+    use diesel::{update, ExpressionMethods};
+
+    CrateBuilder::new("foo_show", user.id)
+        .description("description")
+        .documentation("https://example.com")
+        .homepage("http://example.com")
+        .version(VersionBuilder::new("1.0.0"))
+        .version(VersionBuilder::new("0.5.0"))
+        .version(VersionBuilder::new("0.5.1"))
+        .keyword("kw1")
+        .downloads(20)
+        .recent_downloads(10)
+        .expect_build(&mut conn);
+
+    // Make version 1.0.0 mimic a version published before we started recording who published
+    // versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .filter(versions::num.eq("1.0.0"))
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
 
     let response = anon.get::<()>("/api/v1/crates/foo_show").await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -51,21 +48,20 @@ async fn show() {
 #[tokio::test(flavor = "multi_thread")]
 async fn show_minimal() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_show_minimal", user.id)
-            .description("description")
-            .documentation("https://example.com")
-            .homepage("http://example.com")
-            .version(VersionBuilder::new("1.0.0"))
-            .version(VersionBuilder::new("0.5.0"))
-            .version(VersionBuilder::new("0.5.1"))
-            .keyword("kw1")
-            .downloads(20)
-            .recent_downloads(10)
-            .expect_build(conn)
-    });
+    CrateBuilder::new("foo_show_minimal", user.id)
+        .description("description")
+        .documentation("https://example.com")
+        .homepage("http://example.com")
+        .version(VersionBuilder::new("1.0.0"))
+        .version(VersionBuilder::new("0.5.0"))
+        .version(VersionBuilder::new("0.5.1"))
+        .keyword("kw1")
+        .downloads(20)
+        .recent_downloads(10)
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/foo_show_minimal?include=")
@@ -122,13 +118,12 @@ async fn version_size() {
 #[tokio::test(flavor = "multi_thread")]
 async fn block_bad_documentation_url() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_bad_doc_url", user.id)
-            .documentation("http://rust-ci.org/foo/foo_bad_doc_url/doc/foo_bad_doc_url/")
-            .expect_build(conn)
-    });
+    CrateBuilder::new("foo_bad_doc_url", user.id)
+        .documentation("http://rust-ci.org/foo/foo_bad_doc_url/doc/foo_bad_doc_url/")
+        .expect_build(&mut conn);
 
     let json = anon.show_crate("foo_bad_doc_url").await;
     assert_eq!(json.krate.documentation, None);
@@ -137,7 +132,9 @@ async fn block_bad_documentation_url() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_new_name() {
     let (app, anon, user) = TestApp::init().with_user();
-    app.db(|conn| CrateBuilder::new("new", user.as_model().id).expect_build(conn));
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("new", user.as_model().id).expect_build(&mut conn);
 
     let response = anon.get::<()>("/api/v1/crates/new?include=").await;
     assert_eq!(response.status(), StatusCode::OK);
diff --git a/src/tests/routes/crates/reverse_dependencies.rs b/src/tests/routes/crates/reverse_dependencies.rs
index 750824d140f..a027e1c7672 100644
--- a/src/tests/routes/crates/reverse_dependencies.rs
+++ b/src/tests/routes/crates/reverse_dependencies.rs
@@ -6,19 +6,19 @@ use insta::{assert_json_snapshot, assert_snapshot};
 #[tokio::test(flavor = "multi_thread")]
 async fn reverse_dependencies() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("c1", user.id).expect_build(conn);
-        CrateBuilder::new("c2", user.id)
-            .version(VersionBuilder::new("1.0.0").dependency(&c1, None))
-            .version(
-                VersionBuilder::new("1.1.0")
-                    .dependency(&c1, None)
-                    .dependency(&c1, Some("foo")),
-            )
-            .expect_build(conn);
-    });
+    let c1 = CrateBuilder::new("c1", user.id).expect_build(&mut conn);
+
+    CrateBuilder::new("c2", user.id)
+        .version(VersionBuilder::new("1.0.0").dependency(&c1, None))
+        .version(
+            VersionBuilder::new("1.1.0")
+                .dependency(&c1, None)
+                .dependency(&c1, Some("foo")),
+        )
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -43,17 +43,17 @@ async fn reverse_dependencies() {
 #[tokio::test(flavor = "multi_thread")]
 async fn reverse_dependencies_when_old_version_doesnt_depend_but_new_does() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("c1", user.id)
-            .version("1.1.0")
-            .expect_build(conn);
-        CrateBuilder::new("c2", user.id)
-            .version("1.0.0")
-            .version(VersionBuilder::new("2.0.0").dependency(&c1, None))
-            .expect_build(conn);
-    });
+    let c1 = CrateBuilder::new("c1", user.id)
+        .version("1.1.0")
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("c2", user.id)
+        .version("1.0.0")
+        .version(VersionBuilder::new("2.0.0").dependency(&c1, None))
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -68,17 +68,17 @@ async fn reverse_dependencies_when_old_version_doesnt_depend_but_new_does() {
 #[tokio::test(flavor = "multi_thread")]
 async fn reverse_dependencies_when_old_version_depended_but_new_doesnt() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("c1", user.id)
-            .version("1.0.0")
-            .expect_build(conn);
-        CrateBuilder::new("c2", user.id)
-            .version(VersionBuilder::new("1.0.0").dependency(&c1, None))
-            .version("2.0.0")
-            .expect_build(conn);
-    });
+    let c1 = CrateBuilder::new("c1", user.id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("c2", user.id)
+        .version(VersionBuilder::new("1.0.0").dependency(&c1, None))
+        .version("2.0.0")
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -93,20 +93,21 @@ async fn reverse_dependencies_when_old_version_depended_but_new_doesnt() {
 #[tokio::test(flavor = "multi_thread")]
 async fn prerelease_versions_not_included_in_reverse_dependencies() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("c1", user.id)
-            .version("1.0.0")
-            .expect_build(conn);
-        CrateBuilder::new("c2", user.id)
-            .version("1.1.0-pre")
-            .expect_build(conn);
-        CrateBuilder::new("c3", user.id)
-            .version(VersionBuilder::new("1.0.0").dependency(&c1, None))
-            .version("1.1.0-pre")
-            .expect_build(conn);
-    });
+    let c1 = CrateBuilder::new("c1", user.id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("c2", user.id)
+        .version("1.1.0-pre")
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("c3", user.id)
+        .version(VersionBuilder::new("1.0.0").dependency(&c1, None))
+        .version("1.1.0-pre")
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -121,17 +122,17 @@ async fn prerelease_versions_not_included_in_reverse_dependencies() {
 #[tokio::test(flavor = "multi_thread")]
 async fn yanked_versions_not_included_in_reverse_dependencies() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("c1", user.id)
-            .version("1.0.0")
-            .expect_build(conn);
-        CrateBuilder::new("c2", user.id)
-            .version("1.0.0")
-            .version(VersionBuilder::new("2.0.0").dependency(&c1, None))
-            .expect_build(conn);
-    });
+    let c1 = CrateBuilder::new("c1", user.id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("c2", user.id)
+        .version("1.0.0")
+        .version(VersionBuilder::new("2.0.0").dependency(&c1, None))
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -142,15 +143,13 @@ async fn yanked_versions_not_included_in_reverse_dependencies() {
         ".versions[].updated_at" => "[datetime]",
     });
 
-    app.db(|conn| {
-        use crate::schema::versions;
-        use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl};
+    use crate::schema::versions;
+    use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl};
 
-        diesel::update(versions::table.filter(versions::num.eq("2.0.0")))
-            .set(versions::yanked.eq(true))
-            .execute(conn)
-            .unwrap();
-    });
+    diesel::update(versions::table.filter(versions::num.eq("2.0.0")))
+        .set(versions::yanked.eq(true))
+        .execute(&mut conn)
+        .unwrap();
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -165,32 +164,31 @@ async fn yanked_versions_not_included_in_reverse_dependencies() {
 #[tokio::test(flavor = "multi_thread")]
 async fn reverse_dependencies_includes_published_by_user_when_present() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        use crate::schema::versions;
-        use diesel::{update, ExpressionMethods, RunQueryDsl};
-
-        let c1 = CrateBuilder::new("c1", user.id)
-            .version("1.0.0")
-            .expect_build(conn);
-        CrateBuilder::new("c2", user.id)
-            .version(VersionBuilder::new("2.0.0").dependency(&c1, None))
-            .expect_build(conn);
-
-        // Make c2's version (and,incidentally, c1's, but that doesn't matter) mimic a version
-        // published before we started recording who published versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
-
-        // c3's version will have the published by info recorded
-        CrateBuilder::new("c3", user.id)
-            .version(VersionBuilder::new("3.0.0").dependency(&c1, None))
-            .expect_build(conn);
-    });
+    use crate::schema::versions;
+    use diesel::{update, ExpressionMethods, RunQueryDsl};
+
+    let c1 = CrateBuilder::new("c1", user.id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
+    CrateBuilder::new("c2", user.id)
+        .version(VersionBuilder::new("2.0.0").dependency(&c1, None))
+        .expect_build(&mut conn);
+
+    // Make c2's version (and,incidentally, c1's, but that doesn't matter) mimic a version
+    // published before we started recording who published versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
+
+    // c3's version will have the published by info recorded
+    CrateBuilder::new("c3", user.id)
+        .version(VersionBuilder::new("3.0.0").dependency(&c1, None))
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
@@ -205,18 +203,18 @@ async fn reverse_dependencies_includes_published_by_user_when_present() {
 #[tokio::test(flavor = "multi_thread")]
 async fn reverse_dependencies_query_supports_u64_version_number_parts() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
     let large_but_valid_version_number = format!("1.0.{}", u64::MAX);
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("c1", user.id).expect_build(conn);
-        // The crate that depends on c1...
-        CrateBuilder::new("c2", user.id)
-            // ...has a patch version at the limits of what the semver crate supports
-            .version(VersionBuilder::new(&large_but_valid_version_number).dependency(&c1, None))
-            .expect_build(conn);
-    });
+    let c1 = CrateBuilder::new("c1", user.id).expect_build(&mut conn);
+
+    // The crate that depends on c1...
+    CrateBuilder::new("c2", user.id)
+        // ...has a patch version at the limits of what the semver crate supports
+        .version(VersionBuilder::new(&large_but_valid_version_number).dependency(&c1, None))
+        .expect_build(&mut conn);
 
     let response = anon
         .get::<()>("/api/v1/crates/c1/reverse_dependencies")
diff --git a/src/tests/routes/crates/versions/authors.rs b/src/tests/routes/crates/versions/authors.rs
index ebd56625a70..d78706b073b 100644
--- a/src/tests/routes/crates/versions/authors.rs
+++ b/src/tests/routes/crates/versions/authors.rs
@@ -6,13 +6,12 @@ use serde_json::Value;
 #[tokio::test(flavor = "multi_thread")]
 async fn authors() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_authors", user.id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo_authors", user.id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let json: Value = anon
         .get("/api/v1/crates/foo_authors/1.0.0/authors")
diff --git a/src/tests/routes/crates/versions/dependencies.rs b/src/tests/routes/crates/versions/dependencies.rs
index 87a2b4f65e7..ebaf44bec88 100644
--- a/src/tests/routes/crates/versions/dependencies.rs
+++ b/src/tests/routes/crates/versions/dependencies.rs
@@ -12,15 +12,14 @@ pub struct Deps {
 #[tokio::test(flavor = "multi_thread")]
 async fn dependencies() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c1 = CrateBuilder::new("foo_deps", user.id).expect_build(conn);
-        let c2 = CrateBuilder::new("bar_deps", user.id).expect_build(conn);
-        VersionBuilder::new("1.0.0")
-            .dependency(&c2, None)
-            .expect_build(c1.id, user.id, conn);
-    });
+    let c1 = CrateBuilder::new("foo_deps", user.id).expect_build(&mut conn);
+    let c2 = CrateBuilder::new("bar_deps", user.id).expect_build(&mut conn);
+    VersionBuilder::new("1.0.0")
+        .dependency(&c2, None)
+        .expect_build(c1.id, user.id, &mut conn);
 
     let deps: Deps = anon
         .get("/api/v1/crates/foo_deps/1.0.0/dependencies")
diff --git a/src/tests/routes/crates/versions/download.rs b/src/tests/routes/crates/versions/download.rs
index 35e20e51870..bca69293514 100644
--- a/src/tests/routes/crates/versions/download.rs
+++ b/src/tests/routes/crates/versions/download.rs
@@ -4,12 +4,11 @@ use crate::tests::util::{RequestHelper, TestApp};
 #[tokio::test(flavor = "multi_thread")]
 async fn test_redirects() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo-download", user.as_model().id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo-download", user.as_model().id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
     // Any redirect to an existing crate and version works correctly.
     anon.get::<()>("/api/v1/crates/foo-download/1.0.0/download")
@@ -35,13 +34,12 @@ async fn test_redirects() {
 #[tokio::test(flavor = "multi_thread")]
 async fn download_with_build_metadata() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", user.id)
-            .version(VersionBuilder::new("1.0.0+bar"))
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo", user.id)
+        .version(VersionBuilder::new("1.0.0+bar"))
+        .expect_build(&mut conn);
 
     anon.get::<()>("/api/v1/crates/foo/1.0.0+bar/download")
         .await
diff --git a/src/tests/routes/crates/versions/list.rs b/src/tests/routes/crates/versions/list.rs
index bc29c80a75d..581267a798a 100644
--- a/src/tests/routes/crates/versions/list.rs
+++ b/src/tests/routes/crates/versions/list.rs
@@ -10,22 +10,23 @@ use insta::{assert_json_snapshot, assert_snapshot};
 #[tokio::test(flavor = "multi_thread")]
 async fn versions() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("foo_versions", user.id)
-            .version("0.5.1")
-            .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
-            .version("0.5.0")
-            .expect_build(conn);
-        // Make version 1.0.0 mimic a version published before we started recording who published
-        // versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .filter(versions::num.eq("1.0.0"))
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
-    });
+
+    CrateBuilder::new("foo_versions", user.id)
+        .version("0.5.1")
+        .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
+        .version("0.5.0")
+        .expect_build(&mut conn);
+
+    // Make version 1.0.0 mimic a version published before we started recording who published
+    // versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .filter(versions::num.eq("1.0.0"))
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
 
     let response = anon.get::<()>("/api/v1/crates/foo_versions/versions").await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -47,6 +48,8 @@ async fn test_unknown_crate() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_sorting() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
+
     let user = user.as_model();
     let versions = [
         "1.0.0-alpha",
@@ -59,32 +62,31 @@ async fn test_sorting() {
         "1.0.0-rc.1",
         "1.0.0",
     ];
-    app.db(|conn| {
-        let mut builder = CrateBuilder::new("foo_versions", user.id);
-        for version in versions {
-            builder = builder.version(version);
-        }
-        builder.expect_build(conn);
-        // Make version 1.0.0-beta.2 and 1.0.0-alpha.beta mimic versions created at same time,
-        // but 1.0.0-alpha.beta owns larger id number
-        let versions_aliased = diesel::alias!(versions as versions_aliased);
-        let created_at_by_num = |num: &str| {
-            versions_aliased
-                .filter(versions_aliased.field(versions::num).eq(num.to_owned()))
-                .select(versions_aliased.field(versions::created_at))
-                .single_value()
-        };
-        update(versions::table)
-            .filter(versions::num.eq("1.0.0-beta.2"))
-            .set(versions::created_at.eq(created_at_by_num("1.0.0-alpha.beta").assume_not_null()))
-            .execute(conn)
-            .unwrap();
-
-        // An additional crate to guarantee the accuracy of the response dataset and its total
-        CrateBuilder::new("bar_versions", user.id)
-            .version("0.0.1")
-            .expect_build(conn);
-    });
+
+    let mut builder = CrateBuilder::new("foo_versions", user.id);
+    for version in versions {
+        builder = builder.version(version);
+    }
+    builder.expect_build(&mut conn);
+    // Make version 1.0.0-beta.2 and 1.0.0-alpha.beta mimic versions created at same time,
+    // but 1.0.0-alpha.beta owns larger id number
+    let versions_aliased = diesel::alias!(versions as versions_aliased);
+    let created_at_by_num = |num: &str| {
+        versions_aliased
+            .filter(versions_aliased.field(versions::num).eq(num.to_owned()))
+            .select(versions_aliased.field(versions::created_at))
+            .single_value()
+    };
+    update(versions::table)
+        .filter(versions::num.eq("1.0.0-beta.2"))
+        .set(versions::created_at.eq(created_at_by_num("1.0.0-alpha.beta").assume_not_null()))
+        .execute(&mut conn)
+        .unwrap();
+
+    // An additional crate to guarantee the accuracy of the response dataset and its total
+    CrateBuilder::new("bar_versions", user.id)
+        .version("0.0.1")
+        .expect_build(&mut conn);
 
     let expects = [
         "2.0.0-alpha",
@@ -148,22 +150,23 @@ async fn test_sorting() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_seek_based_pagination_semver_sorting() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("foo_versions", user.id)
-            .version(VersionBuilder::new("0.5.1").yanked(true))
-            .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
-            .version("0.5.0")
-            .expect_build(conn);
-        // Make version 1.0.0 mimic a version published before we started recording who published
-        // versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .filter(versions::num.eq("1.0.0"))
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
-    });
+
+    CrateBuilder::new("foo_versions", user.id)
+        .version(VersionBuilder::new("0.5.1").yanked(true))
+        .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
+        .version("0.5.0")
+        .expect_build(&mut conn);
+
+    // Make version 1.0.0 mimic a version published before we started recording who published
+    // versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .filter(versions::num.eq("1.0.0"))
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
 
     let url = "/api/v1/crates/foo_versions/versions";
     let expects = ["1.0.0", "0.5.1", "0.5.0"];
@@ -230,22 +233,23 @@ async fn test_seek_based_pagination_semver_sorting() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_seek_based_pagination_date_sorting() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("foo_versions", user.id)
-            .version(VersionBuilder::new("0.5.1").yanked(true))
-            .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
-            .version("0.5.0")
-            .expect_build(conn);
-        // Make version 1.0.0 mimic a version published before we started recording who published
-        // versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .filter(versions::num.eq("1.0.0"))
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
-    });
+
+    CrateBuilder::new("foo_versions", user.id)
+        .version(VersionBuilder::new("0.5.1").yanked(true))
+        .version(VersionBuilder::new("1.0.0").rust_version("1.64"))
+        .version("0.5.0")
+        .expect_build(&mut conn);
+
+    // Make version 1.0.0 mimic a version published before we started recording who published
+    // versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .filter(versions::num.eq("1.0.0"))
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
 
     let url = "/api/v1/crates/foo_versions/versions";
     let expects = ["0.5.0", "1.0.0", "0.5.1"];
@@ -315,10 +319,10 @@ async fn test_seek_based_pagination_date_sorting() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invalid_seek_parameter() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("foo_versions", user.id).expect_build(conn);
-    });
+
+    CrateBuilder::new("foo_versions", user.id).expect_build(&mut conn);
 
     let url = "/api/v1/crates/foo_versions/versions";
     // Sort by semver
diff --git a/src/tests/routes/crates/versions/read.rs b/src/tests/routes/crates/versions/read.rs
index 8eada6264ba..f7459056934 100644
--- a/src/tests/routes/crates/versions/read.rs
+++ b/src/tests/routes/crates/versions/read.rs
@@ -7,16 +7,15 @@ use serde_json::Value;
 #[tokio::test(flavor = "multi_thread")]
 async fn show_by_crate_name_and_version() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let v = app.db(|conn| {
-        let krate = CrateBuilder::new("foo_vers_show", user.id).expect_build(conn);
-        VersionBuilder::new("2.0.0")
-            .size(1234)
-            .checksum("c241cd77c3723ccf1aa453f169ee60c0a888344da504bee0142adb859092acb4")
-            .rust_version("1.64")
-            .expect_build(krate.id, user.id, conn)
-    });
+    let krate = CrateBuilder::new("foo_vers_show", user.id).expect_build(&mut conn);
+    let v = VersionBuilder::new("2.0.0")
+        .size(1234)
+        .checksum("c241cd77c3723ccf1aa453f169ee60c0a888344da504bee0142adb859092acb4")
+        .rust_version("1.64")
+        .expect_build(krate.id, user.id, &mut conn);
 
     let url = "/api/v1/crates/foo_vers_show/2.0.0";
     let json: Value = anon.get(url).await.good();
@@ -34,26 +33,23 @@ async fn show_by_crate_name_and_semver_no_published_by() {
     use diesel::{update, RunQueryDsl};
 
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let v = app.db(|conn| {
-        let krate = CrateBuilder::new("foo_vers_show_no_pb", user.id).expect_build(conn);
-        let version = VersionBuilder::new("1.0.0").expect_build(krate.id, user.id, conn);
-
-        // Mimic a version published before we started recording who published versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
+    let krate = CrateBuilder::new("foo_vers_show_no_pb", user.id).expect_build(&mut conn);
+    let version = VersionBuilder::new("1.0.0").expect_build(krate.id, user.id, &mut conn);
 
-        version
-    });
+    // Mimic a version published before we started recording who published versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
 
     let url = "/api/v1/crates/foo_vers_show_no_pb/1.0.0";
     let json: Value = anon.get(url).await.good();
     assert_json_snapshot!(json, {
-        ".version.id" => insta::id_redaction(v.id),
+        ".version.id" => insta::id_redaction(version.id),
         ".version.created_at" => "[datetime]",
         ".version.updated_at" => "[datetime]",
     });
diff --git a/src/tests/routes/crates/versions/yank_unyank.rs b/src/tests/routes/crates/versions/yank_unyank.rs
index 26011389291..e55f98c4f23 100644
--- a/src/tests/routes/crates/versions/yank_unyank.rs
+++ b/src/tests/routes/crates/versions/yank_unyank.rs
@@ -63,14 +63,14 @@ impl<T: RequestHelper> YankRequestHelper for T {
 #[tokio::test(flavor = "multi_thread")]
 async fn yank_by_a_non_owner_fails() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
 
     let another_user = app.db_new_user("bar");
     let another_user = another_user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("foo_not", another_user.id)
-            .version("1.0.0")
-            .expect_build(conn);
-    });
+
+    CrateBuilder::new("foo_not", another_user.id)
+        .version("1.0.0")
+        .expect_build(&mut conn);
 
     let response = token.yank("foo_not", "1.0.0").await;
     assert_eq!(response.status(), StatusCode::FORBIDDEN);
@@ -144,15 +144,15 @@ mod auth {
     }
 
     fn is_yanked(app: &TestApp) -> bool {
-        app.db(|conn| {
-            versions::table
-                .inner_join(crates::table)
-                .select(versions::yanked)
-                .filter(crates::name.eq(CRATE_NAME))
-                .filter(versions::num.eq(CRATE_VERSION))
-                .get_result(conn)
-                .unwrap()
-        })
+        let mut conn = app.db_conn();
+
+        versions::table
+            .inner_join(crates::table)
+            .select(versions::yanked)
+            .filter(crates::name.eq(CRATE_NAME))
+            .filter(versions::num.eq(CRATE_VERSION))
+            .get_result(&mut conn)
+            .unwrap()
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -365,15 +365,14 @@ mod auth {
     #[tokio::test(flavor = "multi_thread")]
     async fn admin() {
         let (app, _, _) = prepare().await;
+        let mut conn = app.db_conn();
 
         let admin = app.db_new_user("admin");
 
-        app.db(|conn| {
-            diesel::update(admin.as_model())
-                .set(users::is_admin.eq(true))
-                .execute(conn)
-                .unwrap();
-        });
+        diesel::update(admin.as_model())
+            .set(users::is_admin.eq(true))
+            .execute(&mut conn)
+            .unwrap();
 
         let response = admin.yank(CRATE_NAME, CRATE_VERSION).await;
         assert_eq!(response.status(), StatusCode::OK);
diff --git a/src/tests/routes/keywords/list.rs b/src/tests/routes/keywords/list.rs
index caf1ef80946..89ec966fbe3 100644
--- a/src/tests/routes/keywords/list.rs
+++ b/src/tests/routes/keywords/list.rs
@@ -17,13 +17,13 @@ struct KeywordMeta {
 async fn index() {
     let url = "/api/v1/keywords";
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
+
     let json: KeywordList = anon.get(url).await.good();
     assert_eq!(json.keywords.len(), 0);
     assert_eq!(json.meta.total, 0);
 
-    app.db(|conn| {
-        Keyword::find_or_create_all(conn, &["foo"]).unwrap();
-    });
+    Keyword::find_or_create_all(&mut conn, &["foo"]).unwrap();
 
     let json: KeywordList = anon.get(url).await.good();
     assert_eq!(json.keywords.len(), 1);
diff --git a/src/tests/routes/keywords/read.rs b/src/tests/routes/keywords/read.rs
index 58cb7bad89d..74c8e5896c1 100644
--- a/src/tests/routes/keywords/read.rs
+++ b/src/tests/routes/keywords/read.rs
@@ -12,11 +12,12 @@ struct GoodKeyword {
 async fn show() {
     let url = "/api/v1/keywords/foo";
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
+
     anon.get(url).await.assert_not_found();
 
-    app.db(|conn| {
-        Keyword::find_or_create_all(conn, &["foo"]).unwrap();
-    });
+    Keyword::find_or_create_all(&mut conn, &["foo"]).unwrap();
+
     let json: GoodKeyword = anon.get(url).await.good();
     assert_eq!(json.keyword.keyword.as_str(), "foo");
 }
@@ -25,11 +26,12 @@ async fn show() {
 async fn uppercase() {
     let url = "/api/v1/keywords/UPPER";
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
+
     anon.get(url).await.assert_not_found();
 
-    app.db(|conn| {
-        Keyword::find_or_create_all(conn, &["UPPER"]).unwrap();
-    });
+    Keyword::find_or_create_all(&mut conn, &["UPPER"]).unwrap();
+
     let json: GoodKeyword = anon.get(url).await.good();
     assert_eq!(json.keyword.keyword.as_str(), "upper");
 }
@@ -37,6 +39,7 @@ async fn uppercase() {
 #[tokio::test(flavor = "multi_thread")]
 async fn update_crate() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
     async fn cnt(kw: &str, client: &impl RequestHelper) -> usize {
@@ -44,44 +47,30 @@ async fn update_crate() {
         json.keyword.crates_cnt as usize
     }
 
-    let krate = app.db(|conn| {
-        Keyword::find_or_create_all(conn, &["kw1", "kw2"]).unwrap();
-        CrateBuilder::new("fookey", user.id).expect_build(conn)
-    });
+    Keyword::find_or_create_all(&mut conn, &["kw1", "kw2"]).unwrap();
+    let krate = CrateBuilder::new("fookey", user.id).expect_build(&mut conn);
 
-    app.db(|conn| {
-        Keyword::update_crate(conn, &krate, &[]).unwrap();
-    });
+    Keyword::update_crate(&mut conn, &krate, &[]).unwrap();
     assert_eq!(cnt("kw1", &anon).await, 0);
     assert_eq!(cnt("kw2", &anon).await, 0);
 
-    app.db(|conn| {
-        Keyword::update_crate(conn, &krate, &["kw1"]).unwrap();
-    });
+    Keyword::update_crate(&mut conn, &krate, &["kw1"]).unwrap();
     assert_eq!(cnt("kw1", &anon).await, 1);
     assert_eq!(cnt("kw2", &anon).await, 0);
 
-    app.db(|conn| {
-        Keyword::update_crate(conn, &krate, &["kw2"]).unwrap();
-    });
+    Keyword::update_crate(&mut conn, &krate, &["kw2"]).unwrap();
     assert_eq!(cnt("kw1", &anon).await, 0);
     assert_eq!(cnt("kw2", &anon).await, 1);
 
-    app.db(|conn| {
-        Keyword::update_crate(conn, &krate, &[]).unwrap();
-    });
+    Keyword::update_crate(&mut conn, &krate, &[]).unwrap();
     assert_eq!(cnt("kw1", &anon).await, 0);
     assert_eq!(cnt("kw2", &anon).await, 0);
 
-    app.db(|conn| {
-        Keyword::update_crate(conn, &krate, &["kw1", "kw2"]).unwrap();
-    });
+    Keyword::update_crate(&mut conn, &krate, &["kw1", "kw2"]).unwrap();
     assert_eq!(cnt("kw1", &anon).await, 1);
     assert_eq!(cnt("kw2", &anon).await, 1);
 
-    app.db(|conn| {
-        Keyword::update_crate(conn, &krate, &[]).unwrap();
-    });
+    Keyword::update_crate(&mut conn, &krate, &[]).unwrap();
     assert_eq!(cnt("kw1", &anon).await, 0);
     assert_eq!(cnt("kw2", &anon).await, 0);
 }
diff --git a/src/tests/routes/me/email_notifications.rs b/src/tests/routes/me/email_notifications.rs
index d21dd3c1029..d743dab19fe 100644
--- a/src/tests/routes/me/email_notifications.rs
+++ b/src/tests/routes/me/email_notifications.rs
@@ -26,21 +26,15 @@ impl crate::tests::util::MockCookieUser {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_update_email_notifications() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    let my_crates = app.db(|conn| {
-        vec![
-            CrateBuilder::new("test_package", user.as_model().id).expect_build(conn),
-            CrateBuilder::new("another_package", user.as_model().id).expect_build(conn),
-        ]
-    });
-
-    let a_id = my_crates.first().unwrap().id;
-    let b_id = my_crates.get(1).unwrap().id;
+    let a = CrateBuilder::new("test_package", user.as_model().id).expect_build(&mut conn);
+    let b = CrateBuilder::new("another_package", user.as_model().id).expect_build(&mut conn);
 
     // Update crate_a: email_notifications = false
     // crate_a should be false, crate_b should be true
     user.update_email_notifications(vec![EmailNotificationsUpdate {
-        id: a_id,
+        id: a.id,
         email_notifications: false,
     }])
     .await;
@@ -50,14 +44,14 @@ async fn test_update_email_notifications() {
         !json
             .owned_crates
             .iter()
-            .find(|c| c.id == a_id)
+            .find(|c| c.id == a.id)
             .unwrap()
             .email_notifications
     );
     assert!(
         json.owned_crates
             .iter()
-            .find(|c| c.id == b_id)
+            .find(|c| c.id == b.id)
             .unwrap()
             .email_notifications
     );
@@ -65,7 +59,7 @@ async fn test_update_email_notifications() {
     // Update crate_b: email_notifications = false
     // Both should be false now
     user.update_email_notifications(vec![EmailNotificationsUpdate {
-        id: b_id,
+        id: b.id,
         email_notifications: false,
     }])
     .await;
@@ -75,7 +69,7 @@ async fn test_update_email_notifications() {
         !json
             .owned_crates
             .iter()
-            .find(|c| c.id == a_id)
+            .find(|c| c.id == a.id)
             .unwrap()
             .email_notifications
     );
@@ -83,7 +77,7 @@ async fn test_update_email_notifications() {
         !json
             .owned_crates
             .iter()
-            .find(|c| c.id == b_id)
+            .find(|c| c.id == b.id)
             .unwrap()
             .email_notifications
     );
@@ -92,11 +86,11 @@ async fn test_update_email_notifications() {
     // Both should be true
     user.update_email_notifications(vec![
         EmailNotificationsUpdate {
-            id: a_id,
+            id: a.id,
             email_notifications: true,
         },
         EmailNotificationsUpdate {
-            id: b_id,
+            id: b.id,
             email_notifications: true,
         },
     ])
@@ -113,13 +107,13 @@ async fn test_update_email_notifications() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_update_email_notifications_not_owned() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
+
+    let u = new_user("arbitrary_username")
+        .create_or_update(None, &app.as_inner().emails, &mut conn)
+        .unwrap();
 
-    let not_my_crate = app.db(|conn| {
-        let u = new_user("arbitrary_username")
-            .create_or_update(None, &app.as_inner().emails, conn)
-            .unwrap();
-        CrateBuilder::new("test_package", u.id).expect_build(conn)
-    });
+    let not_my_crate = CrateBuilder::new("test_package", u.id).expect_build(&mut conn);
 
     user.update_email_notifications(vec![EmailNotificationsUpdate {
         id: not_my_crate.id,
@@ -127,13 +121,10 @@ async fn test_update_email_notifications_not_owned() {
     }])
     .await;
 
-    let email_notifications: bool = app
-        .db(|conn| {
-            crate_owners::table
-                .select(crate_owners::email_notifications)
-                .filter(crate_owners::crate_id.eq(not_my_crate.id))
-                .first(conn)
-        })
+    let email_notifications: bool = crate_owners::table
+        .select(crate_owners::email_notifications)
+        .filter(crate_owners::crate_id.eq(not_my_crate.id))
+        .first(&mut conn)
         .unwrap();
 
     // There should be no change to the `email_notifications` value for a crate not belonging to me
diff --git a/src/tests/routes/me/get.rs b/src/tests/routes/me/get.rs
index 98733ef5f66..547df40f123 100644
--- a/src/tests/routes/me/get.rs
+++ b/src/tests/routes/me/get.rs
@@ -20,6 +20,7 @@ pub struct UserShowPrivateResponse {
 #[tokio::test(flavor = "multi_thread")]
 async fn me() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
     let response = anon.get::<()>("/api/v1/me").await;
     assert_eq!(response.status(), StatusCode::FORBIDDEN);
@@ -29,9 +30,7 @@ async fn me() {
     assert_eq!(response.status(), StatusCode::OK);
     assert_json_snapshot!(response.json());
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_my_packages", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_my_packages", user.as_model().id).expect_build(&mut conn);
 
     let response = user.get::<()>("/api/v1/me").await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -41,12 +40,11 @@ async fn me() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_user_owned_crates_doesnt_include_deleted_ownership() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user_model = user.as_model();
 
-    app.db(|conn| {
-        let krate = CrateBuilder::new("foo_my_packages", user_model.id).expect_build(conn);
-        krate.owner_remove(conn, &user_model.gh_login).unwrap();
-    });
+    let krate = CrateBuilder::new("foo_my_packages", user_model.id).expect_build(&mut conn);
+    krate.owner_remove(&mut conn, &user_model.gh_login).unwrap();
 
     let json = user.show_me().await;
     assert_eq!(json.owned_crates.len(), 0);
diff --git a/src/tests/routes/me/tokens/create.rs b/src/tests/routes/me/tokens/create.rs
index d8aaa51ceda..105fc48af4b 100644
--- a/src/tests/routes/me/tokens/create.rs
+++ b/src/tests/routes/me/tokens/create.rs
@@ -41,12 +41,13 @@ async fn create_token_no_name() {
 #[tokio::test(flavor = "multi_thread")]
 async fn create_token_exceeded_tokens_per_user() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let id = user.as_model().id;
-    app.db(|conn| {
-        for i in 0..1000 {
-            assert_ok!(ApiToken::insert(conn, id, &format!("token {i}")));
-        }
-    });
+
+    for i in 0..1000 {
+        assert_ok!(ApiToken::insert(&mut conn, id, &format!("token {i}")));
+    }
+
     let response = user.put::<()>("/api/v1/me/tokens", NEW_BAR).await;
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
     assert_snapshot!(response.text(), @r#"{"errors":[{"detail":"maximum tokens per user is: 500"}]}"#);
@@ -56,6 +57,7 @@ async fn create_token_exceeded_tokens_per_user() {
 #[tokio::test(flavor = "multi_thread")]
 async fn create_token_success() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
     let response = user.put::<()>("/api/v1/me/tokens", NEW_BAR).await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -66,11 +68,10 @@ async fn create_token_success() {
         ".api_token.token" => insta::api_token_redaction(),
     });
 
-    let tokens: Vec<ApiToken> = app.db(|conn| {
-        assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .load(conn))
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .load(&mut conn));
+
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, "bar");
     assert!(!tokens[0].revoked);
@@ -119,6 +120,7 @@ async fn cannot_create_token_with_token() {
 #[tokio::test(flavor = "multi_thread")]
 async fn create_token_with_scopes() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
     let json = json!({
         "api_token": {
@@ -139,11 +141,10 @@ async fn create_token_with_scopes() {
         ".api_token.token" => insta::api_token_redaction(),
     });
 
-    let tokens: Vec<ApiToken> = app.db(|conn| {
-        assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .load(conn))
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .load(&mut conn));
+
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, "bar");
     assert!(!tokens[0].revoked);
@@ -166,6 +167,7 @@ async fn create_token_with_scopes() {
 #[tokio::test(flavor = "multi_thread")]
 async fn create_token_with_null_scopes() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
     let json = json!({
         "api_token": {
@@ -186,11 +188,10 @@ async fn create_token_with_null_scopes() {
         ".api_token.token" => insta::api_token_redaction(),
     });
 
-    let tokens: Vec<ApiToken> = app.db(|conn| {
-        assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .load(conn))
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .load(&mut conn));
+
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, "bar");
     assert!(!tokens[0].revoked);
diff --git a/src/tests/routes/me/tokens/delete.rs b/src/tests/routes/me/tokens/delete.rs
index 80e748220f0..280ebb7c3e6 100644
--- a/src/tests/routes/me/tokens/delete.rs
+++ b/src/tests/routes/me/tokens/delete.rs
@@ -15,18 +15,17 @@ async fn revoke_token_non_existing() {
 #[tokio::test(flavor = "multi_thread")]
 async fn revoke_token_doesnt_revoke_other_users_token() {
     let (app, _, user1, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let user1 = user1.as_model();
     let token = token.as_model();
     let user2 = app.db_new_user("baz");
 
     // List tokens for first user contains the token
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user1)
-            .select(ApiToken::as_select())
-            .load(conn));
-        assert_eq!(tokens.len(), 1);
-        assert_eq!(tokens[0].name, token.name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user1)
+        .select(ApiToken::as_select())
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 1);
+    assert_eq!(tokens[0].name, token.name);
 
     // Try revoke the token as second user
     let _json: RevokedResponse = user2
@@ -35,27 +34,24 @@ async fn revoke_token_doesnt_revoke_other_users_token() {
         .good();
 
     // List tokens for first user still contains the token
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user1)
-            .select(ApiToken::as_select())
-            .load(conn));
-        assert_eq!(tokens.len(), 1);
-        assert_eq!(tokens[0].name, token.name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user1)
+        .select(ApiToken::as_select())
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 1);
+    assert_eq!(tokens[0].name, token.name);
 }
 
 #[tokio::test(flavor = "multi_thread")]
 async fn revoke_token_success() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     // List tokens contains the token
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .load(conn));
-        assert_eq!(tokens.len(), 1);
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 1);
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     // Revoke the token
     let _json: RevokedResponse = user
@@ -64,11 +60,9 @@ async fn revoke_token_success() {
         .good();
 
     // List tokens no longer contains the token
-    app.db(|conn| {
-        let count = ApiToken::belonging_to(user.as_model())
-            .filter(api_tokens::revoked.eq(false))
-            .count()
-            .get_result(conn);
-        assert_eq!(count, Ok(0));
-    });
+    let count = ApiToken::belonging_to(user.as_model())
+        .filter(api_tokens::revoked.eq(false))
+        .count()
+        .get_result(&mut conn);
+    assert_eq!(count, Ok(0));
 }
diff --git a/src/tests/routes/me/tokens/delete_current.rs b/src/tests/routes/me/tokens/delete_current.rs
index 6680dcd6b25..f14896a4a5f 100644
--- a/src/tests/routes/me/tokens/delete_current.rs
+++ b/src/tests/routes/me/tokens/delete_current.rs
@@ -8,29 +8,28 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn revoke_current_token_success() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     // Ensure that the token currently exists in the database
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_eq!(tokens.len(), 1);
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 1);
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     // Revoke the token
     let response = token.delete::<()>("/api/v1/tokens/current").await;
     assert_eq!(response.status(), StatusCode::NO_CONTENT);
 
     // Ensure that the token was removed from the database
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_eq!(tokens.len(), 0);
-    });
+
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 0);
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -45,16 +44,16 @@ async fn revoke_current_token_without_auth() {
 #[tokio::test(flavor = "multi_thread")]
 async fn revoke_current_token_with_cookie_user() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     // Ensure that the token currently exists in the database
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_eq!(tokens.len(), 1);
-        assert_eq!(tokens[0].name, token.as_model().name);
-    });
+
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 1);
+    assert_eq!(tokens[0].name, token.as_model().name);
 
     // Revoke the token
     let response = user.delete::<()>("/api/v1/tokens/current").await;
@@ -62,11 +61,10 @@ async fn revoke_current_token_with_cookie_user() {
     assert_snapshot!(response.text(), @r#"{"errors":[{"detail":"token not provided"}]}"#);
 
     // Ensure that the token still exists in the database after the failed request
-    app.db(|conn| {
-        let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .filter(api_tokens::revoked.eq(false))
-            .load(conn));
-        assert_eq!(tokens.len(), 1);
-    });
+
+    let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .filter(api_tokens::revoked.eq(false))
+        .load(&mut conn));
+    assert_eq!(tokens.len(), 1);
 }
diff --git a/src/tests/routes/me/tokens/get.rs b/src/tests/routes/me/tokens/get.rs
index e6f5455d73f..1db99956d2b 100644
--- a/src/tests/routes/me/tokens/get.rs
+++ b/src/tests/routes/me/tokens/get.rs
@@ -27,22 +27,22 @@ async fn show() {
 #[tokio::test(flavor = "multi_thread")]
 async fn show_token_with_scopes() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user_model = user.as_model();
     let id = user_model.id;
-    let token = app.db(|conn| {
-        assert_ok!(ApiToken::insert(conn, id, "bar"));
-        assert_ok!(ApiToken::insert_with_scopes(
-            conn,
-            id,
-            "baz",
-            Some(vec![
-                CrateScope::try_from("serde").unwrap(),
-                CrateScope::try_from("serde-*").unwrap()
-            ]),
-            Some(vec![EndpointScope::PublishUpdate]),
-            Some((Utc::now() - Duration::days(31)).naive_utc()),
-        ))
-    });
+
+    assert_ok!(ApiToken::insert(&mut conn, id, "bar"));
+    let token = assert_ok!(ApiToken::insert_with_scopes(
+        &mut conn,
+        id,
+        "baz",
+        Some(vec![
+            CrateScope::try_from("serde").unwrap(),
+            CrateScope::try_from("serde-*").unwrap()
+        ]),
+        Some(vec![EndpointScope::PublishUpdate]),
+        Some((Utc::now() - Duration::days(31)).naive_utc()),
+    ));
 
     let url = format!("/api/v1/me/tokens/{}", token.model.id);
     let response = user.get::<()>(&url).await;
@@ -63,9 +63,11 @@ async fn show_with_anonymous_user() {
 #[tokio::test(flavor = "multi_thread")]
 async fn show_other_user_token() {
     let (app, _, user1) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user2 = app.db_new_user("baz");
     let user2 = user2.as_model();
-    let token = app.db(|conn| assert_ok!(ApiToken::insert(conn, user2.id, "bar")));
+
+    let token = assert_ok!(ApiToken::insert(&mut conn, user2.id, "bar"));
 
     let url = format!("/api/v1/me/tokens/{}", token.model.id);
     let response = user1.get::<()>(&url).await;
diff --git a/src/tests/routes/me/tokens/list.rs b/src/tests/routes/me/tokens/list.rs
index 53f4ed4b0bf..5c21177f4c9 100644
--- a/src/tests/routes/me/tokens/list.rs
+++ b/src/tests/routes/me/tokens/list.rs
@@ -29,31 +29,29 @@ async fn list_empty() {
 #[tokio::test(flavor = "multi_thread")]
 async fn list_tokens() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let id = user.as_model().id;
-    app.db(|conn| {
-        vec![
-            assert_ok!(ApiToken::insert(conn, id, "bar")),
-            assert_ok!(ApiToken::insert_with_scopes(
-                conn,
-                id,
-                "baz",
-                Some(vec![
-                    CrateScope::try_from("serde").unwrap(),
-                    CrateScope::try_from("serde-*").unwrap()
-                ]),
-                Some(vec![EndpointScope::PublishUpdate]),
-                None
-            )),
-            assert_ok!(ApiToken::insert_with_scopes(
-                conn,
-                id,
-                "qux",
-                None,
-                None,
-                Some((Utc::now() - Duration::days(1)).naive_utc()),
-            )),
-        ]
-    });
+
+    assert_ok!(ApiToken::insert(&mut conn, id, "bar"));
+    assert_ok!(ApiToken::insert_with_scopes(
+        &mut conn,
+        id,
+        "baz",
+        Some(vec![
+            CrateScope::try_from("serde").unwrap(),
+            CrateScope::try_from("serde-*").unwrap()
+        ]),
+        Some(vec![EndpointScope::PublishUpdate]),
+        None
+    ));
+    assert_ok!(ApiToken::insert_with_scopes(
+        &mut conn,
+        id,
+        "qux",
+        None,
+        None,
+        Some((Utc::now() - Duration::days(1)).naive_utc()),
+    ));
 
     let response = user.get::<()>("/api/v1/me/tokens").await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -72,31 +70,29 @@ async fn list_recently_expired_tokens() {
     }
 
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let id = user.as_model().id;
-    app.db(|conn| {
-        vec![
-            assert_ok!(ApiToken::insert(conn, id, "bar")),
-            assert_ok!(ApiToken::insert_with_scopes(
-                conn,
-                id,
-                "ancient",
-                Some(vec![
-                    CrateScope::try_from("serde").unwrap(),
-                    CrateScope::try_from("serde-*").unwrap()
-                ]),
-                Some(vec![EndpointScope::PublishUpdate]),
-                Some((Utc::now() - Duration::days(31)).naive_utc()),
-            )),
-            assert_ok!(ApiToken::insert_with_scopes(
-                conn,
-                id,
-                "recent",
-                None,
-                None,
-                Some((Utc::now() - Duration::days(1)).naive_utc()),
-            )),
-        ]
-    });
+
+    assert_ok!(ApiToken::insert(&mut conn, id, "bar"));
+    assert_ok!(ApiToken::insert_with_scopes(
+        &mut conn,
+        id,
+        "ancient",
+        Some(vec![
+            CrateScope::try_from("serde").unwrap(),
+            CrateScope::try_from("serde-*").unwrap()
+        ]),
+        Some(vec![EndpointScope::PublishUpdate]),
+        Some((Utc::now() - Duration::days(31)).naive_utc()),
+    ));
+    assert_ok!(ApiToken::insert_with_scopes(
+        &mut conn,
+        id,
+        "recent",
+        None,
+        None,
+        Some((Utc::now() - Duration::days(1)).naive_utc()),
+    ));
 
     let response = user.get::<()>("/api/v1/me/tokens?expired_days=30").await;
     assert_eq!(response.status(), StatusCode::OK);
@@ -119,13 +115,11 @@ async fn list_recently_expired_tokens() {
 #[tokio::test(flavor = "multi_thread")]
 async fn list_tokens_exclude_revoked() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let id = user.as_model().id;
-    let tokens = app.db(|conn| {
-        vec![
-            assert_ok!(ApiToken::insert(conn, id, "bar")),
-            assert_ok!(ApiToken::insert(conn, id, "baz")),
-        ]
-    });
+
+    let token1 = assert_ok!(ApiToken::insert(&mut conn, id, "bar"));
+    assert_ok!(ApiToken::insert(&mut conn, id, "baz"));
 
     // List tokens expecting them all to be there.
     let response = user.get::<()>("/api/v1/me/tokens").await;
@@ -136,7 +130,7 @@ async fn list_tokens_exclude_revoked() {
 
     // Revoke the first token.
     let response = user
-        .delete::<()>(&format!("/api/v1/me/tokens/{}", tokens[0].model.id))
+        .delete::<()>(&format!("/api/v1/me/tokens/{}", token1.model.id))
         .await;
     assert_eq!(response.status(), StatusCode::OK);
 
diff --git a/src/tests/routes/me/updates.rs b/src/tests/routes/me/updates.rs
index 8f36380b9e7..6db24c35cb0 100644
--- a/src/tests/routes/me/updates.rs
+++ b/src/tests/routes/me/updates.rs
@@ -28,25 +28,25 @@ async fn following() {
     }
 
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user_model = user.as_model();
     let user_id = user_model.id;
-    app.db(|conn| {
-        CrateBuilder::new("foo_fighters", user_id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
 
-        // Make foo_fighters's version mimic a version published before we started recording who
-        // published versions
-        let none: Option<i32> = None;
-        update(versions::table)
-            .set(versions::published_by.eq(none))
-            .execute(conn)
-            .unwrap();
+    CrateBuilder::new("foo_fighters", user_id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
-        CrateBuilder::new("bar_fighters", user_id)
-            .version(VersionBuilder::new("1.0.0"))
-            .expect_build(conn);
-    });
+    // Make foo_fighters's version mimic a version published before we started recording who
+    // published versions
+    let none: Option<i32> = None;
+    update(versions::table)
+        .set(versions::published_by.eq(none))
+        .execute(&mut conn)
+        .unwrap();
+
+    CrateBuilder::new("bar_fighters", user_id)
+        .version(VersionBuilder::new("1.0.0"))
+        .expect_build(&mut conn);
 
     let r: R = user.get("/api/v1/me/updates").await.good();
     assert_that!(r.versions, empty());
diff --git a/src/tests/routes/private/crate_owner_invitations.rs b/src/tests/routes/private/crate_owner_invitations.rs
index 486ecb31d21..68fa3737764 100644
--- a/src/tests/routes/private/crate_owner_invitations.rs
+++ b/src/tests/routes/private/crate_owner_invitations.rs
@@ -28,13 +28,11 @@ async fn get_invitations(user: &MockCookieUser, query: &str) -> CrateOwnerInvita
 #[tokio::test(flavor = "multi_thread")]
 async fn invitation_list() {
     let (app, _, owner, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
+
+    let crate1 = CrateBuilder::new("crate_1", owner.as_model().id).expect_build(&mut conn);
+    let crate2 = CrateBuilder::new("crate_2", owner.as_model().id).expect_build(&mut conn);
 
-    let (crate1, crate2) = app.db(|conn| {
-        (
-            CrateBuilder::new("crate_1", owner.as_model().id).expect_build(conn),
-            CrateBuilder::new("crate_2", owner.as_model().id).expect_build(conn),
-        )
-    });
     let user1 = app.db_new_user("user_1");
     let user2 = app.db_new_user("user_2");
     token.add_named_owner("crate_1", "user_1").await.good();
@@ -167,14 +165,12 @@ async fn invitation_list() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invitations_list_does_not_include_expired_invites() {
     let (app, _, owner, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("invited_user");
 
-    let (crate1, crate2) = app.db(|conn| {
-        (
-            CrateBuilder::new("crate_1", owner.as_model().id).expect_build(conn),
-            CrateBuilder::new("crate_2", owner.as_model().id).expect_build(conn),
-        )
-    });
+    let crate1 = CrateBuilder::new("crate_1", owner.as_model().id).expect_build(&mut conn);
+    let crate2 = CrateBuilder::new("crate_2", owner.as_model().id).expect_build(&mut conn);
+
     token
         .add_named_owner("crate_1", "invited_user")
         .await
@@ -213,14 +209,12 @@ async fn invitations_list_does_not_include_expired_invites() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invitations_list_paginated() {
     let (app, _, owner, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("invited_user");
 
-    let (crate1, crate2) = app.db(|conn| {
-        (
-            CrateBuilder::new("crate_1", owner.as_model().id).expect_build(conn),
-            CrateBuilder::new("crate_2", owner.as_model().id).expect_build(conn),
-        )
-    });
+    let crate1 = CrateBuilder::new("crate_1", owner.as_model().id).expect_build(&mut conn);
+    let crate2 = CrateBuilder::new("crate_2", owner.as_model().id).expect_build(&mut conn);
+
     token
         .add_named_owner("crate_1", "invited_user")
         .await
@@ -331,11 +325,11 @@ async fn invitation_list_other_users() {
 #[tokio::test(flavor = "multi_thread")]
 async fn invitation_list_other_crates() {
     let (app, _, owner, _) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let other_user = app.db_new_user("other");
-    app.db(|conn| {
-        CrateBuilder::new("crate_1", owner.as_model().id).expect_build(conn);
-        CrateBuilder::new("crate_2", other_user.as_model().id).expect_build(conn);
-    });
+
+    CrateBuilder::new("crate_1", owner.as_model().id).expect_build(&mut conn);
+    CrateBuilder::new("crate_2", other_user.as_model().id).expect_build(&mut conn);
 
     // Retrieving our own invitations work.
     let resp = owner
diff --git a/src/tests/routes/summary.rs b/src/tests/routes/summary.rs
index 4c7b08005b1..49add01c86b 100644
--- a/src/tests/routes/summary.rs
+++ b/src/tests/routes/summary.rs
@@ -27,62 +27,62 @@ async fn summary_doesnt_die() {
 #[tokio::test(flavor = "multi_thread")]
 async fn summary_new_crates() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        let _: anyhow::Result<()> = conn.transaction(|conn| {
-            let now_ = Utc::now().naive_utc();
-            let now_plus_two = now_ + chrono::Duration::seconds(2);
-
-            new_category("Category 1", "cat1", "Category 1 crates")
-                .create_or_update(conn)
-                .unwrap();
-
-            CrateBuilder::new("some_downloads", user.id)
-                .version(VersionBuilder::new("0.1.0"))
-                .description("description")
-                .keyword("popular")
-                .category("cat1")
-                .downloads(20)
-                .recent_downloads(10)
-                .expect_build(conn);
-
-            CrateBuilder::new("most_recent_downloads", user.id)
-                .version(VersionBuilder::new("0.2.0"))
-                .keyword("popular")
-                .category("cat1")
-                .downloads(5000)
-                .recent_downloads(50)
-                .expect_build(conn);
-
-            CrateBuilder::new("just_updated", user.id)
-                .version(VersionBuilder::new("0.1.0"))
-                .version(VersionBuilder::new("0.1.2"))
-                // update 'just_updated' krate. Others won't appear because updated_at == created_at.
-                .updated_at(now_)
-                .expect_build(conn);
-
-            CrateBuilder::new("just_updated_patch", user.id)
-                .version(VersionBuilder::new("0.1.0"))
-                .version(VersionBuilder::new("0.2.0"))
-                // Add a patch version be newer than the other versions, including the higher one.
-                .version(VersionBuilder::new("0.1.1").created_at(now_plus_two))
-                .updated_at(now_plus_two)
-                .expect_build(conn);
-
-            CrateBuilder::new("with_downloads", user.id)
-                .version(VersionBuilder::new("0.3.0"))
-                .keyword("popular")
-                .downloads(1000)
-                .expect_build(conn);
-
-            // set total_downloads global value for `num_downloads` prop
-            update(metadata::table)
-                .set(metadata::total_downloads.eq(6000))
-                .execute(conn)
-                .unwrap();
-
-            Ok(())
-        });
+
+    let _: anyhow::Result<()> = conn.transaction(|conn| {
+        let now_ = Utc::now().naive_utc();
+        let now_plus_two = now_ + chrono::Duration::seconds(2);
+
+        new_category("Category 1", "cat1", "Category 1 crates")
+            .create_or_update(conn)
+            .unwrap();
+
+        CrateBuilder::new("some_downloads", user.id)
+            .version(VersionBuilder::new("0.1.0"))
+            .description("description")
+            .keyword("popular")
+            .category("cat1")
+            .downloads(20)
+            .recent_downloads(10)
+            .expect_build(conn);
+
+        CrateBuilder::new("most_recent_downloads", user.id)
+            .version(VersionBuilder::new("0.2.0"))
+            .keyword("popular")
+            .category("cat1")
+            .downloads(5000)
+            .recent_downloads(50)
+            .expect_build(conn);
+
+        CrateBuilder::new("just_updated", user.id)
+            .version(VersionBuilder::new("0.1.0"))
+            .version(VersionBuilder::new("0.1.2"))
+            // update 'just_updated' krate. Others won't appear because updated_at == created_at.
+            .updated_at(now_)
+            .expect_build(conn);
+
+        CrateBuilder::new("just_updated_patch", user.id)
+            .version(VersionBuilder::new("0.1.0"))
+            .version(VersionBuilder::new("0.2.0"))
+            // Add a patch version be newer than the other versions, including the higher one.
+            .version(VersionBuilder::new("0.1.1").created_at(now_plus_two))
+            .updated_at(now_plus_two)
+            .expect_build(conn);
+
+        CrateBuilder::new("with_downloads", user.id)
+            .version(VersionBuilder::new("0.3.0"))
+            .keyword("popular")
+            .downloads(1000)
+            .expect_build(conn);
+
+        // set total_downloads global value for `num_downloads` prop
+        update(metadata::table)
+            .set(metadata::total_downloads.eq(6000))
+            .execute(conn)
+            .unwrap();
+
+        Ok(())
     });
 
     let json: SummaryResponse = anon.get("/api/v1/summary").await.good();
@@ -124,25 +124,26 @@ async fn excluded_crate_id() {
             ];
         })
         .with_user();
+
+    let mut conn = app.db_conn();
     let user = user.as_model();
-    app.db(|conn| {
-        CrateBuilder::new("some_downloads", user.id)
-            .version(VersionBuilder::new("0.1.0"))
-            .description("description")
-            .keyword("popular")
-            .category("cat1")
-            .downloads(20)
-            .recent_downloads(10)
-            .expect_build(conn);
 
-        CrateBuilder::new("most_recent_downloads", user.id)
-            .version(VersionBuilder::new("0.2.0"))
-            .keyword("popular")
-            .category("cat1")
-            .downloads(5000)
-            .recent_downloads(50)
-            .expect_build(conn);
-    });
+    CrateBuilder::new("some_downloads", user.id)
+        .version(VersionBuilder::new("0.1.0"))
+        .description("description")
+        .keyword("popular")
+        .category("cat1")
+        .downloads(20)
+        .recent_downloads(10)
+        .expect_build(&mut conn);
+
+    CrateBuilder::new("most_recent_downloads", user.id)
+        .version(VersionBuilder::new("0.2.0"))
+        .keyword("popular")
+        .category("cat1")
+        .downloads(5000)
+        .recent_downloads(50)
+        .expect_build(&mut conn);
 
     let json: SummaryResponse = anon.get("/api/v1/summary").await.good();
 
diff --git a/src/tests/routes/users/read.rs b/src/tests/routes/users/read.rs
index 6e4f4c24550..e26c6a16a0e 100644
--- a/src/tests/routes/users/read.rs
+++ b/src/tests/routes/users/read.rs
@@ -23,32 +23,31 @@ async fn show() {
 #[tokio::test(flavor = "multi_thread")]
 async fn show_latest_user_case_insensitively() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        // Please do not delete or modify the setup of this test in order to get it to pass.
-        // This setup mimics how GitHub works. If someone abandons a GitHub account, the username is
-        // available for anyone to take. We need to support having multiple user accounts
-        // with the same gh_login in crates.io. `gh_id` is stable across renames, so that field
-        // should be used for uniquely identifying GitHub accounts whenever possible. For the
-        // crates.io/user/:username pages, the best we can do is show the last crates.io account
-        // created with that username.
-        assert_ok!(NewUser::new(
-            1,
-            "foobar",
-            Some("I was first then deleted my github account"),
-            None,
-            "bar"
-        )
-        .create_or_update(None, &app.as_inner().emails, conn));
-        assert_ok!(NewUser::new(
-            2,
-            "FOOBAR",
-            Some("I was second, I took the foobar username on github"),
-            None,
-            "bar"
-        )
-        .create_or_update(None, &app.as_inner().emails, conn));
-    });
+    // Please do not delete or modify the setup of this test in order to get it to pass.
+    // This setup mimics how GitHub works. If someone abandons a GitHub account, the username is
+    // available for anyone to take. We need to support having multiple user accounts
+    // with the same gh_login in crates.io. `gh_id` is stable across renames, so that field
+    // should be used for uniquely identifying GitHub accounts whenever possible. For the
+    // crates.io/user/:username pages, the best we can do is show the last crates.io account
+    // created with that username.
+    assert_ok!(NewUser::new(
+        1,
+        "foobar",
+        Some("I was first then deleted my github account"),
+        None,
+        "bar"
+    )
+    .create_or_update(None, &app.as_inner().emails, &mut conn));
+    assert_ok!(NewUser::new(
+        2,
+        "FOOBAR",
+        Some("I was second, I took the foobar username on github"),
+        None,
+        "bar"
+    )
+    .create_or_update(None, &app.as_inner().emails, &mut conn));
 
     let json: UserShowPublicResponse = anon.get("/api/v1/users/fOObAr").await.good();
     assert_eq!(
diff --git a/src/tests/routes/users/stats.rs b/src/tests/routes/users/stats.rs
index e3dbbed0fcc..86a7c3687e9 100644
--- a/src/tests/routes/users/stats.rs
+++ b/src/tests/routes/users/stats.rs
@@ -14,38 +14,37 @@ async fn user_total_downloads() {
     use diesel::{update, QueryDsl, RunQueryDsl};
 
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
     let another_user = app.db_new_user("bar");
     let another_user = another_user.as_model();
 
-    app.db(|conn| {
-        let krate = CrateBuilder::new("foo_krate1", user.id).expect_build(conn);
-        update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate.id)))
-            .set(crate_downloads::downloads.eq(10))
-            .execute(conn)
-            .unwrap();
-
-        let krate2 = CrateBuilder::new("foo_krate2", user.id).expect_build(conn);
-        update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate2.id)))
-            .set(crate_downloads::downloads.eq(20))
-            .execute(conn)
-            .unwrap();
-
-        let another_krate = CrateBuilder::new("bar_krate1", another_user.id).expect_build(conn);
-        update(crate_downloads::table.filter(crate_downloads::crate_id.eq(another_krate.id)))
-            .set(crate_downloads::downloads.eq(2))
-            .execute(conn)
-            .unwrap();
-
-        let no_longer_my_krate = CrateBuilder::new("nacho", user.id).expect_build(conn);
-        update(crate_downloads::table.filter(crate_downloads::crate_id.eq(no_longer_my_krate.id)))
-            .set(crate_downloads::downloads.eq(5))
-            .execute(conn)
-            .unwrap();
-        no_longer_my_krate
-            .owner_remove(conn, &user.gh_login)
-            .unwrap();
-    });
+    let krate = CrateBuilder::new("foo_krate1", user.id).expect_build(&mut conn);
+    update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate.id)))
+        .set(crate_downloads::downloads.eq(10))
+        .execute(&mut conn)
+        .unwrap();
+
+    let krate2 = CrateBuilder::new("foo_krate2", user.id).expect_build(&mut conn);
+    update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate2.id)))
+        .set(crate_downloads::downloads.eq(20))
+        .execute(&mut conn)
+        .unwrap();
+
+    let another_krate = CrateBuilder::new("bar_krate1", another_user.id).expect_build(&mut conn);
+    update(crate_downloads::table.filter(crate_downloads::crate_id.eq(another_krate.id)))
+        .set(crate_downloads::downloads.eq(2))
+        .execute(&mut conn)
+        .unwrap();
+
+    let no_longer_my_krate = CrateBuilder::new("nacho", user.id).expect_build(&mut conn);
+    update(crate_downloads::table.filter(crate_downloads::crate_id.eq(no_longer_my_krate.id)))
+        .set(crate_downloads::downloads.eq(5))
+        .execute(&mut conn)
+        .unwrap();
+    no_longer_my_krate
+        .owner_remove(&mut conn, &user.gh_login)
+        .unwrap();
 
     let url = format!("/api/v1/users/{}/stats", user.id);
     let stats: UserStats = anon.get(&url).await.good();
diff --git a/src/tests/schema_details.rs b/src/tests/schema_details.rs
index 5e527855879..42ba0627900 100644
--- a/src/tests/schema_details.rs
+++ b/src/tests/schema_details.rs
@@ -71,11 +71,10 @@ fn get_fk_constraint_definitions(column_name: &str) -> Vec<TableNameAndConstrain
     use diesel::sql_query;
 
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        sql_query(include_str!("load_foreign_key_constraints.sql"))
-            .bind::<Text, _>(column_name)
-            .load(conn)
-            .unwrap()
-    })
+    sql_query(include_str!("load_foreign_key_constraints.sql"))
+        .bind::<Text, _>(column_name)
+        .load(&mut conn)
+        .unwrap()
 }
diff --git a/src/tests/server.rs b/src/tests/server.rs
index 45873aa0b55..b7719354c7f 100644
--- a/src/tests/server.rs
+++ b/src/tests/server.rs
@@ -26,10 +26,9 @@ async fn user_agent_is_required() {
 #[tokio::test(flavor = "multi_thread")]
 async fn user_agent_is_not_required_for_download() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("dl_no_ua", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("dl_no_ua", user.as_model().id).expect_build(&mut conn);
 
     let uri = "/api/v1/crates/dl_no_ua/0.99.0/download";
     let req = Request::get(uri).body("").unwrap();
@@ -45,9 +44,9 @@ async fn blocked_traffic_doesnt_panic_if_checked_header_is_not_present() {
         })
         .with_user();
 
-    app.db(|conn| {
-        CrateBuilder::new("dl_no_ua", user.as_model().id).expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("dl_no_ua", user.as_model().id).expect_build(&mut conn);
 
     let uri = "/api/v1/crates/dl_no_ua/0.99.0/download";
     let req = Request::get(uri).body("").unwrap();
@@ -63,9 +62,9 @@ async fn block_traffic_via_arbitrary_header_and_value() {
         })
         .with_user();
 
-    app.db(|conn| {
-        CrateBuilder::new("dl_no_ua", user.as_model().id).expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("dl_no_ua", user.as_model().id).expect_build(&mut conn);
 
     let req = Request::get("/api/v1/crates/dl_no_ua/0.99.0/download")
         // A request with a header value we want to block isn't allowed
diff --git a/src/tests/team.rs b/src/tests/team.rs
index 726fb4aa4f7..a08f8b2799a 100644
--- a/src/tests/team.rs
+++ b/src/tests/team.rs
@@ -28,9 +28,9 @@ impl crate::tests::util::MockAnonymousUser {
 async fn not_github() {
     let (app, _, user, token) = TestApp::init().with_token();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_not_github", user.as_model().id).expect_build(conn);
-    });
+    let mut conn = app.db_conn();
+
+    CrateBuilder::new("foo_not_github", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .add_named_owner("foo_not_github", "dropbox:foo:foo")
@@ -42,10 +42,9 @@ async fn not_github() {
 #[tokio::test(flavor = "multi_thread")]
 async fn weird_name() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_weird_name", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_weird_name", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .add_named_owner("foo_weird_name", "github:foo/../bar:wut")
@@ -58,10 +57,9 @@ async fn weird_name() {
 #[tokio::test(flavor = "multi_thread")]
 async fn one_colon() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_one_colon", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_one_colon", user.as_model().id).expect_build(&mut conn);
 
     let response = token.add_named_owner("foo_one_colon", "github:foo").await;
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
@@ -71,10 +69,9 @@ async fn one_colon() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_nonexistent_team() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_add_nonexistent", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_add_nonexistent", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .add_named_owner("foo_add_nonexistent", "github:test-org:this-does-not-exist")
@@ -87,29 +84,31 @@ async fn add_nonexistent_team() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_renamed_team() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("user-all-teams");
     let token = user.db_new_token("arbitrary token name");
     let owner_id = user.as_model().id;
 
-    app.db(|conn| {
-        use crate::schema::teams;
+    use crate::schema::teams;
 
-        CrateBuilder::new("foo_renamed_team", owner_id).expect_build(conn);
+    CrateBuilder::new("foo_renamed_team", owner_id).expect_build(&mut conn);
 
-        // create team with same ID and different name compared to http mock
-        // used for `async_add_named_owner`.await
-        NewTeam::new(
-            "github:test-org:old-core", // different team name
-            1000,                       // same org ID
-            2001,                       // same team id as `core` team
-            None,
-            None,
-        )
-        .create_or_update(conn)
-        .unwrap();
+    // create team with same ID and different name compared to http mock
+    // used for `async_add_named_owner`.await
+    NewTeam::new(
+        "github:test-org:old-core", // different team name
+        1000,                       // same org ID
+        2001,                       // same team id as `core` team
+        None,
+        None,
+    )
+    .create_or_update(&mut conn)
+    .unwrap();
 
-        assert_eq!(teams::table.count().get_result::<i64>(conn).unwrap(), 1);
-    });
+    assert_eq!(
+        teams::table.count().get_result::<i64>(&mut conn).unwrap(),
+        1
+    );
 
     token
         .add_named_owner("foo_renamed_team", "github:test-org:core")
@@ -125,25 +124,22 @@ async fn add_renamed_team() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_team_mixed_case() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("user-all-teams");
     let token = user.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_mixed_case", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_mixed_case", user.as_model().id).expect_build(&mut conn);
 
     token
         .add_named_owner("foo_mixed_case", "github:Test-Org:Core")
         .await
         .good();
 
-    app.db(|conn| {
-        let krate: Crate = Crate::by_name("foo_mixed_case").first(conn).unwrap();
-        let owners = krate.owners(conn).unwrap();
-        assert_eq!(owners.len(), 2);
-        let owner = &owners[1];
-        assert_eq!(owner.login(), owner.login().to_lowercase());
-    });
+    let krate: Crate = Crate::by_name("foo_mixed_case").first(&mut conn).unwrap();
+    let owners = krate.owners(&mut conn).unwrap();
+    assert_eq!(owners.len(), 2);
+    let owner = &owners[1];
+    assert_eq!(owner.login(), owner.login().to_lowercase());
 
     let json = anon.crate_owner_teams("foo_mixed_case").await.good();
     assert_eq!(json.teams.len(), 1);
@@ -153,25 +149,22 @@ async fn add_team_mixed_case() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_team_as_org_owner() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("user-org-owner");
     let token = user.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_org_owner", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_org_owner", user.as_model().id).expect_build(&mut conn);
 
     token
         .add_named_owner("foo_org_owner", "github:test-org:core")
         .await
         .good();
 
-    app.db(|conn| {
-        let krate: Crate = Crate::by_name("foo_org_owner").first(conn).unwrap();
-        let owners = krate.owners(conn).unwrap();
-        assert_eq!(owners.len(), 2);
-        let owner = &owners[1];
-        assert_eq!(owner.login(), owner.login().to_lowercase());
-    });
+    let krate: Crate = Crate::by_name("foo_org_owner").first(&mut conn).unwrap();
+    let owners = krate.owners(&mut conn).unwrap();
+    assert_eq!(owners.len(), 2);
+    let owner = &owners[1];
+    assert_eq!(owner.login(), owner.login().to_lowercase());
 
     let json = anon.crate_owner_teams("foo_org_owner").await.good();
     assert_eq!(json.teams.len(), 1);
@@ -182,12 +175,11 @@ async fn add_team_as_org_owner() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_team_as_non_member() {
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("user-one-team");
     let token = user.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_team_non_member", user.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_team_non_member", user.as_model().id).expect_build(&mut conn);
 
     let response = token
         .add_named_owner("foo_team_non_member", "github:test-org:core")
@@ -199,13 +191,12 @@ async fn add_team_as_non_member() {
 #[tokio::test(flavor = "multi_thread")]
 async fn remove_team_as_named_owner() {
     let (app, _) = TestApp::full().empty();
+    let mut conn = app.db_conn();
     let username = "user-all-teams";
     let user_on_both_teams = app.db_new_user(username);
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_remove_team", user_on_both_teams.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_remove_team", user_on_both_teams.as_model().id).expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_remove_team", "github:test-org:core")
@@ -235,13 +226,12 @@ async fn remove_team_as_named_owner() {
 #[tokio::test(flavor = "multi_thread")]
 async fn remove_team_as_team_owner() {
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user_on_both_teams = app.db_new_user("user-all-teams");
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_remove_team_owner", user_on_both_teams.as_model().id)
-            .expect_build(conn);
-    });
+    CrateBuilder::new("foo_remove_team_owner", user_on_both_teams.as_model().id)
+        .expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_remove_team_owner", "github:test-org:all")
@@ -269,17 +259,16 @@ async fn remove_team_as_team_owner() {
 #[tokio::test(flavor = "multi_thread")]
 async fn remove_nonexistent_team() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_remove_nonexistent", user.as_model().id).expect_build(conn);
-        insert_into(teams::table)
-            .values((
-                teams::login.eq("github:test-org:this-does-not-exist"),
-                teams::github_id.eq(5678),
-            ))
-            .execute(conn)
-            .expect("couldn't insert nonexistent team")
-    });
+    CrateBuilder::new("foo_remove_nonexistent", user.as_model().id).expect_build(&mut conn);
+    insert_into(teams::table)
+        .values((
+            teams::login.eq("github:test-org:this-does-not-exist"),
+            teams::github_id.eq(5678),
+        ))
+        .execute(&mut conn)
+        .expect("couldn't insert nonexistent team");
 
     token
         .remove_named_owner(
@@ -294,12 +283,11 @@ async fn remove_nonexistent_team() {
 #[tokio::test(flavor = "multi_thread")]
 async fn publish_not_owned() {
     let (app, _) = TestApp::full().empty();
+    let mut conn = app.db_conn();
     let user_on_both_teams = app.db_new_user("user-all-teams");
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_not_owned", user_on_both_teams.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_not_owned", user_on_both_teams.as_model().id).expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_not_owned", "github:test-org:core")
@@ -317,12 +305,11 @@ async fn publish_not_owned() {
 #[tokio::test(flavor = "multi_thread")]
 async fn publish_org_owner_owned() {
     let (app, _) = TestApp::full().empty();
+    let mut conn = app.db_conn();
     let user_on_both_teams = app.db_new_user("user-all-teams");
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_not_owned", user_on_both_teams.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_not_owned", user_on_both_teams.as_model().id).expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_not_owned", "github:test-org:core")
@@ -341,12 +328,11 @@ async fn publish_org_owner_owned() {
 #[tokio::test(flavor = "multi_thread")]
 async fn publish_owned() {
     let (app, _) = TestApp::full().empty();
+    let mut conn = app.db_conn();
     let user_on_both_teams = app.db_new_user("user-all-teams");
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_team_owned", user_on_both_teams.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_team_owned", user_on_both_teams.as_model().id).expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_team_owned", "github:test-org:all")
@@ -368,12 +354,11 @@ async fn publish_owned() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_owners_as_org_owner() {
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user_on_both_teams = app.db_new_user("user-all-teams");
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_add_owner", user_on_both_teams.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_add_owner", user_on_both_teams.as_model().id).expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_add_owner", "github:test-org:all")
@@ -393,12 +378,11 @@ async fn add_owners_as_org_owner() {
 #[tokio::test(flavor = "multi_thread")]
 async fn add_owners_as_team_owner() {
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user_on_both_teams = app.db_new_user("user-all-teams");
     let token_on_both_teams = user_on_both_teams.db_new_token("arbitrary token name");
 
-    app.db(|conn| {
-        CrateBuilder::new("foo_add_owner", user_on_both_teams.as_model().id).expect_build(conn);
-    });
+    CrateBuilder::new("foo_add_owner", user_on_both_teams.as_model().id).expect_build(&mut conn);
 
     token_on_both_teams
         .add_named_owner("foo_add_owner", "github:test-org:all")
@@ -418,38 +402,34 @@ async fn add_owners_as_team_owner() {
 #[tokio::test(flavor = "multi_thread")]
 async fn crates_by_team_id() {
     let (app, anon, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    let team = app.db(|conn| {
-        let t = new_team("github:test-org:team")
-            .create_or_update(conn)
-            .unwrap();
-        let krate = CrateBuilder::new("foo", user.id).expect_build(conn);
-        add_team_to_crate(&t, &krate, user, conn).unwrap();
-        t
-    });
+    let t = new_team("github:test-org:team")
+        .create_or_update(&mut conn)
+        .unwrap();
+    let krate = CrateBuilder::new("foo", user.id).expect_build(&mut conn);
+    add_team_to_crate(&t, &krate, user, &mut conn).unwrap();
 
-    let json = anon.search(&format!("team_id={}", team.id)).await;
+    let json = anon.search(&format!("team_id={}", t.id)).await;
     assert_eq!(json.crates.len(), 1);
 }
 
 #[tokio::test(flavor = "multi_thread")]
 async fn crates_by_team_id_not_including_deleted_owners() {
     let (app, anon) = TestApp::init().empty();
+    let mut conn = app.db_conn();
     let user = app.db_new_user("user-all-teams");
     let user = user.as_model();
 
-    let team = app.db(|conn| {
-        let t = NewTeam::new("github:test-org:core", 1000, 2001, None, None)
-            .create_or_update(conn)
-            .unwrap();
+    let t = NewTeam::new("github:test-org:core", 1000, 2001, None, None)
+        .create_or_update(&mut conn)
+        .unwrap();
 
-        let krate = CrateBuilder::new("foo", user.id).expect_build(conn);
-        add_team_to_crate(&t, &krate, user, conn).unwrap();
-        krate.owner_remove(conn, &t.login).unwrap();
-        t
-    });
+    let krate = CrateBuilder::new("foo", user.id).expect_build(&mut conn);
+    add_team_to_crate(&t, &krate, user, &mut conn).unwrap();
+    krate.owner_remove(&mut conn, &t.login).unwrap();
 
-    let json = anon.search(&format!("team_id={}", team.id)).await;
+    let json = anon.search(&format!("team_id={}", t.id)).await;
     assert_eq!(json.crates.len(), 0);
 }
diff --git a/src/tests/token.rs b/src/tests/token.rs
index 551de48743b..404cd1e2972 100644
--- a/src/tests/token.rs
+++ b/src/tests/token.rs
@@ -9,6 +9,7 @@ use insta::assert_snapshot;
 async fn using_token_updates_last_used_at() {
     let url = "/api/v1/me";
     let (app, anon, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
 
     anon.get(url).await.assert_forbidden();
     user.get::<EncodableMe>(url).await.good();
@@ -17,11 +18,9 @@ async fn using_token_updates_last_used_at() {
     // Use the token once
     token.search("following=1").await;
 
-    let token: ApiToken = app.db(|conn| {
-        assert_ok!(ApiToken::belonging_to(user.as_model())
-            .select(ApiToken::as_select())
-            .first(conn))
-    });
+    let token: ApiToken = assert_ok!(ApiToken::belonging_to(user.as_model())
+        .select(ApiToken::as_select())
+        .first(&mut conn));
     assert_some!(token.last_used_at);
 
     // Would check that it updates the timestamp here, but the timestamp is
diff --git a/src/tests/unhealthy_database.rs b/src/tests/unhealthy_database.rs
index 6115a25f8e7..f6fe1cd208a 100644
--- a/src/tests/unhealthy_database.rs
+++ b/src/tests/unhealthy_database.rs
@@ -53,13 +53,12 @@ async fn http_error_with_unhealthy_database() {
 #[tokio::test(flavor = "multi_thread")]
 async fn download_requests_with_unhealthy_database_succeed() {
     let (app, anon, _, token) = TestApp::init().with_chaos_proxy().with_token();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        CrateBuilder::new("foo", token.as_model().user_id)
-            .version("1.0.0")
-            .build(conn)
-            .unwrap();
-    });
+    CrateBuilder::new("foo", token.as_model().user_id)
+        .version("1.0.0")
+        .build(&mut conn)
+        .unwrap();
 
     app.primary_db_chaosproxy().break_networking().unwrap();
 
diff --git a/src/tests/user.rs b/src/tests/user.rs
index cfd4537cc8e..41e500c6c50 100644
--- a/src/tests/user.rs
+++ b/src/tests/user.rs
@@ -21,24 +21,23 @@ impl crate::tests::util::MockCookieUser {
 #[tokio::test(flavor = "multi_thread")]
 async fn updating_existing_user_doesnt_change_api_token() {
     let (app, _, user, token) = TestApp::init().with_token();
+    let mut conn = app.db_conn();
     let gh_id = user.as_model().gh_id;
     let token = token.plaintext();
 
-    let user = app.db(|conn| {
-        // Reuse gh_id but use new gh_login and gh_access_token
-        assert_ok!(
-            NewUser::new(gh_id, "bar", None, None, "bar_token").create_or_update(
-                None,
-                &app.as_inner().emails,
-                conn
-            )
-        );
-
-        // Use the original API token to find the now updated user
-        let hashed_token = assert_ok!(HashedToken::parse(token.expose_secret()));
-        let api_token = assert_ok!(ApiToken::find_by_api_token(conn, &hashed_token));
-        assert_ok!(User::find(conn, api_token.user_id))
-    });
+    // Reuse gh_id but use new gh_login and gh_access_token
+    assert_ok!(
+        NewUser::new(gh_id, "bar", None, None, "bar_token").create_or_update(
+            None,
+            &app.as_inner().emails,
+            &mut conn
+        )
+    );
+
+    // Use the original API token to find the now updated user
+    let hashed_token = assert_ok!(HashedToken::parse(token.expose_secret()));
+    let api_token = assert_ok!(ApiToken::find_by_api_token(&mut conn, &hashed_token));
+    let user = assert_ok!(User::find(&mut conn, api_token.user_id));
 
     assert_eq!(user.gh_login, "bar");
     assert_eq!(user.gh_access_token, "bar_token");
@@ -56,17 +55,16 @@ async fn updating_existing_user_doesnt_change_api_token() {
 #[tokio::test(flavor = "multi_thread")]
 async fn github_without_email_does_not_overwrite_email() {
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
 
     // Simulate logging in via GitHub with an account that has no email.
     // Because faking GitHub is terrible, call what GithubUser::save_to_database does directly.
     // Don't use app.db_new_user because it adds a verified email.
-    let user_without_github_email = app.db(|conn| {
-        let u = new_user("arbitrary_username");
-        let u = u
-            .create_or_update(None, &app.as_inner().emails, conn)
-            .unwrap();
-        MockCookieUser::new(&app, u)
-    });
+    let u = new_user("arbitrary_username");
+    let u = u
+        .create_or_update(None, &app.as_inner().emails, &mut conn)
+        .unwrap();
+    let user_without_github_email = MockCookieUser::new(&app, u);
     let user_without_github_email_model = user_without_github_email.as_model();
 
     let json = user_without_github_email.show_me().await;
@@ -79,18 +77,16 @@ async fn github_without_email_does_not_overwrite_email() {
         .await;
 
     // Simulate the same user logging in via GitHub again, still with no email in GitHub.
-    let again_user_without_github_email = app.db(|conn| {
-        let u = NewUser {
-            // Use the same github ID to link to the existing account
-            gh_id: user_without_github_email_model.gh_id,
-            // new_user uses a None email; the rest of the fields are arbitrary
-            ..new_user("arbitrary_username")
-        };
-        let u = u
-            .create_or_update(None, &app.as_inner().emails, conn)
-            .unwrap();
-        MockCookieUser::new(&app, u)
-    });
+    let u = NewUser {
+        // Use the same github ID to link to the existing account
+        gh_id: user_without_github_email_model.gh_id,
+        // new_user uses a None email; the rest of the fields are arbitrary
+        ..new_user("arbitrary_username")
+    };
+    let u = u
+        .create_or_update(None, &app.as_inner().emails, &mut conn)
+        .unwrap();
+    let again_user_without_github_email = MockCookieUser::new(&app, u);
 
     let json = again_user_without_github_email.show_me().await;
     assert_eq!(json.user.email.unwrap(), "apricot@apricots.apricot");
@@ -103,29 +99,28 @@ async fn github_with_email_does_not_overwrite_email() {
     use crate::schema::emails;
 
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let model = user.as_model();
-    let original_email: String = app.db(|conn| {
-        Email::belonging_to(model)
-            .select(emails::email)
-            .first(conn)
-            .unwrap()
-    });
+
+    let original_email: String = Email::belonging_to(model)
+        .select(emails::email)
+        .first(&mut conn)
+        .unwrap();
 
     let new_github_email = "new-email-in-github@example.com";
 
     // Simulate logging in to crates.io after changing your email in GitHub
-    let user_with_different_email_in_github = app.db(|conn| {
-        let u = NewUser {
-            // Use the same github ID to link to the existing account
-            gh_id: model.gh_id,
-            // the rest of the fields are arbitrary
-            ..new_user("arbitrary_username")
-        };
-        let u = u
-            .create_or_update(Some(new_github_email), &app.as_inner().emails, conn)
-            .unwrap();
-        MockCookieUser::new(&app, u)
-    });
+
+    let u = NewUser {
+        // Use the same github ID to link to the existing account
+        gh_id: model.gh_id,
+        // the rest of the fields are arbitrary
+        ..new_user("arbitrary_username")
+    };
+    let u = u
+        .create_or_update(Some(new_github_email), &app.as_inner().emails, &mut conn)
+        .unwrap();
+    let user_with_different_email_in_github = MockCookieUser::new(&app, u);
 
     let json = user_with_different_email_in_github.show_me().await;
     assert_eq!(json.user.email, Some(original_email));
@@ -159,28 +154,25 @@ async fn test_confirm_user_email() {
     use crate::schema::emails;
 
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
 
     // Simulate logging in via GitHub. Don't use app.db_new_user because it inserts a verified
     // email directly into the database and we want to test the verification flow here.
     let email = "potato2@example.com";
 
-    let user = app.db(|conn| {
-        let u = NewUser {
-            ..new_user("arbitrary_username")
-        };
-        let u = u
-            .create_or_update(Some(email), &app.as_inner().emails, conn)
-            .unwrap();
-        MockCookieUser::new(&app, u)
-    });
+    let u = NewUser {
+        ..new_user("arbitrary_username")
+    };
+    let u = u
+        .create_or_update(Some(email), &app.as_inner().emails, &mut conn)
+        .unwrap();
+    let user = MockCookieUser::new(&app, u);
     let user_model = user.as_model();
 
-    let email_token: String = app.db(|conn| {
-        Email::belonging_to(user_model)
-            .select(emails::token)
-            .first(conn)
-            .unwrap()
-    });
+    let email_token: String = Email::belonging_to(user_model)
+        .select(emails::token)
+        .first(&mut conn)
+        .unwrap();
 
     user.confirm_email(&email_token).await;
 
@@ -200,25 +192,24 @@ async fn test_existing_user_email() {
     use diesel::update;
 
     let (app, _) = TestApp::init().empty();
+    let mut conn = app.db_conn();
 
     // Simulate logging in via GitHub. Don't use app.db_new_user because it inserts a verified
     // email directly into the database and we want to test the verification flow here.
     let email = "potahto@example.com";
-    let user = app.db(|conn| {
-        let u = NewUser {
-            ..new_user("arbitrary_username")
-        };
-        let u = u
-            .create_or_update(Some(email), &app.as_inner().emails, conn)
-            .unwrap();
-        update(Email::belonging_to(&u))
-            // Users created before we added verification will have
-            // `NULL` in the `token_generated_at` column.
-            .set(emails::token_generated_at.eq(None::<NaiveDateTime>))
-            .execute(conn)
-            .unwrap();
-        MockCookieUser::new(&app, u)
-    });
+    let u = NewUser {
+        ..new_user("arbitrary_username")
+    };
+    let u = u
+        .create_or_update(Some(email), &app.as_inner().emails, &mut conn)
+        .unwrap();
+    update(Email::belonging_to(&u))
+        // Users created before we added verification will have
+        // `NULL` in the `token_generated_at` column.
+        .set(emails::token_generated_at.eq(None::<NaiveDateTime>))
+        .execute(&mut conn)
+        .unwrap();
+    let user = MockCookieUser::new(&app, u);
 
     let json = user.show_me().await;
     assert_eq!(json.user.email.unwrap(), "potahto@example.com");
diff --git a/src/tests/util.rs b/src/tests/util.rs
index c5d6c477937..04e8f49c94d 100644
--- a/src/tests/util.rs
+++ b/src/tests/util.rs
@@ -299,17 +299,18 @@ impl MockCookieUser {
         endpoint_scopes: Option<Vec<EndpointScope>>,
         expired_at: Option<NaiveDateTime>,
     ) -> MockTokenUser {
-        let token = self.app.db(|conn| {
-            ApiToken::insert_with_scopes(
-                conn,
-                self.user.id,
-                name,
-                crate_scopes,
-                endpoint_scopes,
-                expired_at,
-            )
-            .unwrap()
-        });
+        let mut conn = self.app().db_conn();
+
+        let token = ApiToken::insert_with_scopes(
+            &mut conn,
+            self.user.id,
+            name,
+            crate_scopes,
+            endpoint_scopes,
+            expired_at,
+        )
+        .unwrap();
+
         MockTokenUser {
             app: self.app.clone(),
             token,
diff --git a/src/tests/util/test_app.rs b/src/tests/util/test_app.rs
index e5e32c676d9..86315d40a8f 100644
--- a/src/tests/util/test_app.rs
+++ b/src/tests/util/test_app.rs
@@ -17,6 +17,7 @@ use crates_io_index::{Credentials, RepositoryConfig};
 use crates_io_team_repo::MockTeamRepo;
 use crates_io_test_db::TestDatabase;
 use crates_io_worker::Runner;
+use diesel::r2d2::{ConnectionManager, PooledConnection};
 use diesel::PgConnection;
 use futures_util::TryStreamExt;
 use oauth2::{ClientId, ClientSecret};
@@ -108,13 +109,9 @@ impl TestApp {
         Self::init().with_git_index().with_job_runner()
     }
 
-    /// Obtain the database connection and pass it to the closure
-    ///
-    /// Within each test, the connection pool only has 1 connection so it is necessary to drop the
-    /// connection before making any API calls.  Once the closure returns, the connection is
-    /// dropped, ensuring it is returned to the pool and available for any future API calls.
-    pub fn db<T, F: FnOnce(&mut PgConnection) -> T>(&self, f: F) -> T {
-        f(&mut self.0.test_database.connect())
+    /// Obtain a database connection.
+    pub fn db_conn(&self) -> PooledConnection<ConnectionManager<PgConnection>> {
+        self.0.test_database.connect()
     }
 
     /// Create a new user with a verified email address in the database
@@ -125,23 +122,24 @@ impl TestApp {
         use crate::schema::emails;
         use diesel::prelude::*;
 
-        let user = self.db(|conn| {
-            let email = format!("{username}@example.com");
-
-            let user: User = diesel::insert_into(users::table)
-                .values(crate::tests::new_user(username))
-                .get_result(conn)
-                .unwrap();
-            diesel::insert_into(emails::table)
-                .values((
-                    emails::user_id.eq(user.id),
-                    emails::email.eq(email),
-                    emails::verified.eq(true),
-                ))
-                .execute(conn)
-                .unwrap();
-            user
-        });
+        let mut conn = self.db_conn();
+
+        let email = format!("{username}@example.com");
+
+        let user: User = diesel::insert_into(users::table)
+            .values(crate::tests::new_user(username))
+            .get_result(&mut conn)
+            .unwrap();
+
+        diesel::insert_into(emails::table)
+            .values((
+                emails::user_id.eq(user.id),
+                emails::email.eq(email),
+                emails::verified.eq(true),
+            ))
+            .execute(&mut conn)
+            .unwrap();
+
         MockCookieUser {
             app: self.clone(),
             user,
diff --git a/src/tests/version.rs b/src/tests/version.rs
index 82d9186a137..c2a39f7fcbc 100644
--- a/src/tests/version.rs
+++ b/src/tests/version.rs
@@ -5,13 +5,12 @@ use crate::tests::TestApp;
 #[tokio::test(flavor = "multi_thread")]
 async fn record_rerendered_readme_time() {
     let (app, _, user) = TestApp::init().with_user();
+    let mut conn = app.db_conn();
     let user = user.as_model();
 
-    app.db(|conn| {
-        let c = CrateBuilder::new("foo_authors", user.id).expect_build(conn);
-        let version = VersionBuilder::new("1.0.0").expect_build(c.id, user.id, conn);
+    let c = CrateBuilder::new("foo_authors", user.id).expect_build(&mut conn);
+    let version = VersionBuilder::new("1.0.0").expect_build(c.id, user.id, &mut conn);
 
-        Version::record_readme_rendering(version.id, conn).unwrap();
-        Version::record_readme_rendering(version.id, conn).unwrap();
-    });
+    Version::record_readme_rendering(version.id, &mut conn).unwrap();
+    Version::record_readme_rendering(version.id, &mut conn).unwrap();
 }
diff --git a/src/tests/worker/git.rs b/src/tests/worker/git.rs
index 9c6b75d53ff..ecf8741e08e 100644
--- a/src/tests/worker/git.rs
+++ b/src/tests/worker/git.rs
@@ -9,6 +9,7 @@ use http::StatusCode;
 #[tokio::test(flavor = "multi_thread")]
 async fn index_smoke_test() {
     let (app, _, _, token) = TestApp::full().with_token();
+    let mut conn = app.db_conn();
     let upstream = app.upstream_index();
 
     // Add a new crate
@@ -46,15 +47,13 @@ async fn index_smoke_test() {
 
     // Delete the crate
 
-    app.db(|conn| {
-        use crate::schema::crates;
+    use crate::schema::crates;
 
-        let krate: Crate = assert_ok!(Crate::by_name("serde").first(conn));
-        assert_ok!(diesel::delete(crates::table.find(krate.id)).execute(conn));
+    let krate: Crate = assert_ok!(Crate::by_name("serde").first(&mut conn));
+    assert_ok!(diesel::delete(crates::table.find(krate.id)).execute(&mut conn));
 
-        assert_ok!(jobs::SyncToGitIndex::new("serde").enqueue(conn));
-        assert_ok!(jobs::SyncToSparseIndex::new("serde").enqueue(conn));
-    });
+    assert_ok!(jobs::SyncToGitIndex::new("serde").enqueue(&mut conn));
+    assert_ok!(jobs::SyncToSparseIndex::new("serde").enqueue(&mut conn));
 
     app.run_pending_background_jobs().await;
     assert_ok_eq!(
diff --git a/src/tests/worker/rss/sync_crate_feed.rs b/src/tests/worker/rss/sync_crate_feed.rs
index 19abde8c7be..4371687b0ff 100644
--- a/src/tests/worker/rss/sync_crate_feed.rs
+++ b/src/tests/worker/rss/sync_crate_feed.rs
@@ -10,18 +10,17 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_sync_crate_feed() {
     let (app, _) = TestApp::full().empty();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        create_version(conn, "foo", "0.1.0", "2024-06-20T10:13:54Z");
-        create_version(conn, "foo", "0.1.1", "2024-06-20T12:45:12Z");
-        create_version(conn, "foo", "1.0.0", "2024-06-21T17:01:33Z");
-        create_version(conn, "bar", "3.0.0-beta.1", "2024-06-21T17:03:45Z");
-        create_version(conn, "foo", "1.1.0", "2024-06-22T08:30:01Z");
-        create_version(conn, "foo", "1.2.0", "2024-06-22T15:57:19Z");
+    create_version(&mut conn, "foo", "0.1.0", "2024-06-20T10:13:54Z");
+    create_version(&mut conn, "foo", "0.1.1", "2024-06-20T12:45:12Z");
+    create_version(&mut conn, "foo", "1.0.0", "2024-06-21T17:01:33Z");
+    create_version(&mut conn, "bar", "3.0.0-beta.1", "2024-06-21T17:03:45Z");
+    create_version(&mut conn, "foo", "1.1.0", "2024-06-22T08:30:01Z");
+    create_version(&mut conn, "foo", "1.2.0", "2024-06-22T15:57:19Z");
 
-        let job = jobs::rss::SyncCrateFeed::new("foo".to_string());
-        job.enqueue(conn).unwrap();
-    });
+    let job = jobs::rss::SyncCrateFeed::new("foo".to_string());
+    job.enqueue(&mut conn).unwrap();
 
     app.run_pending_background_jobs().await;
 
diff --git a/src/tests/worker/rss/sync_crates_feed.rs b/src/tests/worker/rss/sync_crates_feed.rs
index 3a076be25e8..dfe01fe424e 100644
--- a/src/tests/worker/rss/sync_crates_feed.rs
+++ b/src/tests/worker/rss/sync_crates_feed.rs
@@ -10,25 +10,24 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_sync_crates_feed() {
     let (app, _) = TestApp::full().empty();
-
-    app.db(|conn| {
-        create_crate(
-            conn,
-            "foo",
-            Some("something something foo"),
-            "2024-06-20T10:13:54Z",
-        );
-        create_crate(conn, "bar", None, "2024-06-20T12:45:12Z");
-        create_crate(
-            conn,
-            "baz",
-            Some("does it handle XML? <item>"),
-            "2024-06-21T17:01:33Z",
-        );
-        create_crate(conn, "quux", None, "2024-06-21T17:03:45Z");
-
-        jobs::rss::SyncCratesFeed.enqueue(conn).unwrap();
-    });
+    let mut conn = app.db_conn();
+
+    create_crate(
+        &mut conn,
+        "foo",
+        Some("something something foo"),
+        "2024-06-20T10:13:54Z",
+    );
+    create_crate(&mut conn, "bar", None, "2024-06-20T12:45:12Z");
+    create_crate(
+        &mut conn,
+        "baz",
+        Some("does it handle XML? <item>"),
+        "2024-06-21T17:01:33Z",
+    );
+    create_crate(&mut conn, "quux", None, "2024-06-21T17:03:45Z");
+
+    jobs::rss::SyncCratesFeed.enqueue(&mut conn).unwrap();
 
     app.run_pending_background_jobs().await;
 
diff --git a/src/tests/worker/rss/sync_updates_feed.rs b/src/tests/worker/rss/sync_updates_feed.rs
index c42085c9895..dc182bbb0d3 100644
--- a/src/tests/worker/rss/sync_updates_feed.rs
+++ b/src/tests/worker/rss/sync_updates_feed.rs
@@ -10,19 +10,24 @@ use insta::assert_snapshot;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_sync_updates_feed() {
     let (app, _) = TestApp::full().empty();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| {
-        let d = "let's try & break this <item>";
+    let d = "let's try & break this <item>";
 
-        create_version(conn, "foo", "0.1.0", None, "2024-06-20T10:13:54Z");
-        create_version(conn, "foo", "0.1.1", None, "2024-06-20T12:45:12Z");
-        create_version(conn, "foo", "1.0.0", None, "2024-06-21T17:01:33Z");
-        create_version(conn, "bar", "3.0.0-beta.1", Some(d), "2024-06-21T17:03:45Z");
-        create_version(conn, "foo", "1.1.0", None, "2024-06-22T08:30:01Z");
-        create_version(conn, "foo", "1.2.0", None, "2024-06-22T15:57:19Z");
+    create_version(&mut conn, "foo", "0.1.0", None, "2024-06-20T10:13:54Z");
+    create_version(&mut conn, "foo", "0.1.1", None, "2024-06-20T12:45:12Z");
+    create_version(&mut conn, "foo", "1.0.0", None, "2024-06-21T17:01:33Z");
+    create_version(
+        &mut conn,
+        "bar",
+        "3.0.0-beta.1",
+        Some(d),
+        "2024-06-21T17:03:45Z",
+    );
+    create_version(&mut conn, "foo", "1.1.0", None, "2024-06-22T08:30:01Z");
+    create_version(&mut conn, "foo", "1.2.0", None, "2024-06-22T15:57:19Z");
 
-        jobs::rss::SyncUpdatesFeed.enqueue(conn).unwrap();
-    });
+    jobs::rss::SyncUpdatesFeed.enqueue(&mut conn).unwrap();
 
     app.run_pending_background_jobs().await;
 
diff --git a/src/tests/worker/sync_admins.rs b/src/tests/worker/sync_admins.rs
index c3fac5bd595..39b8000d578 100644
--- a/src/tests/worker/sync_admins.rs
+++ b/src/tests/worker/sync_admins.rs
@@ -22,20 +22,21 @@ async fn test_sync_admins_job() {
         .returning(move |_| Ok(mock_response.clone()));
 
     let (app, _) = TestApp::full().with_team_repo(team_repo).empty();
+    let mut conn = app.db_conn();
 
-    app.db(|conn| create_user("existing-admin", 1, true, conn).unwrap());
-    app.db(|conn| create_user("obsolete-admin", 2, true, conn).unwrap());
-    app.db(|conn| create_user("new-admin", 3, false, conn).unwrap());
-    app.db(|conn| create_user("unrelated-user", 42, false, conn).unwrap());
+    create_user("existing-admin", 1, true, &mut conn).unwrap();
+    create_user("obsolete-admin", 2, true, &mut conn).unwrap();
+    create_user("new-admin", 3, false, &mut conn).unwrap();
+    create_user("unrelated-user", 42, false, &mut conn).unwrap();
 
-    let admins = app.db(|conn| get_admins(conn).unwrap());
+    let admins = get_admins(&mut conn).unwrap();
     let expected_admins = vec![("existing-admin".into(), 1), ("obsolete-admin".into(), 2)];
     assert_eq!(admins, expected_admins);
 
-    app.db(|conn| SyncAdmins.enqueue(conn).unwrap());
+    SyncAdmins.enqueue(&mut conn).unwrap();
     app.run_pending_background_jobs().await;
 
-    let admins = app.db(|conn| get_admins(conn).unwrap());
+    let admins = get_admins(&mut conn).unwrap();
     let expected_admins = vec![("existing-admin".into(), 1), ("new-admin".into(), 3)];
     assert_eq!(admins, expected_admins);
 
@@ -43,7 +44,7 @@ async fn test_sync_admins_job() {
 
     // Run the job again to verify that no new emails are sent
     // for `new-admin-without-account`.
-    app.db(|conn| SyncAdmins.enqueue(conn).unwrap());
+    SyncAdmins.enqueue(&mut conn).unwrap();
     app.run_pending_background_jobs().await;
 
     assert_eq!(app.emails().len(), 2);