tests/util/test_app: Replace db() with db_conn()

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")]

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")

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;
 

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);

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;
 

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");

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");