Migrate tests from sync to async database connection

src/tests/account_lock.rs

@@ -6,11 +6,12 @@ use insta::assert_snapshot;
 const URL: &str = "/api/v1/me";
 const LOCK_REASON: &str = "test lock reason";
 
-fn lock_account(app: &TestApp, user_id: i32, until: Option<NaiveDateTime>) {
+async fn lock_account(app: &TestApp, user_id: i32, until: Option<NaiveDateTime>) {
     use crate::schema::users;
     use diesel::prelude::*;
+    use diesel_async::RunQueryDsl;
 
-    let mut conn = app.db_conn();
+    let mut conn = app.async_db_conn().await;
 
     diesel::update(users::table)
         .set((
@@ -19,13 +20,14 @@ fn lock_account(app: &TestApp, user_id: i32, until: Option<NaiveDateTime>) {
         ))
         .filter(users::id.eq(user_id))
         .execute(&mut conn)
+        .await
         .unwrap();
 }
 
 #[tokio::test(flavor = "multi_thread")]
 async fn account_locked_indefinitely() {
     let (app, _anon, user) = TestApp::init().with_user();
-    lock_account(&app, user.as_model().id, None);
+    lock_account(&app, user.as_model().id, None).await;
 
     let response = user.get::<()>(URL).await;
     assert_eq!(response.status(), StatusCode::FORBIDDEN);
@@ -40,7 +42,7 @@ async fn account_locked_with_future_expiry() {
         .naive_utc();
 
     let (app, _anon, user) = TestApp::init().with_user();
-    lock_account(&app, user.as_model().id, Some(until));
+    lock_account(&app, user.as_model().id, Some(until)).await;
 
     let response = user.get::<()>(URL).await;
     assert_eq!(response.status(), StatusCode::FORBIDDEN);
@@ -52,7 +54,7 @@ async fn expired_account_lock() {
     let until = Utc::now().naive_utc() - Duration::days(1);
 
     let (app, _anon, user) = TestApp::init().with_user();
-    lock_account(&app, user.as_model().id, Some(until));
+    lock_account(&app, user.as_model().id, Some(until)).await;
 
     user.get::<serde_json::Value>(URL).await.good();
 }

src/tests/github_secret_scanning.rs

@@ -3,6 +3,7 @@ use crate::tests::{RequestHelper, TestApp};
 use crate::util::token::HashedToken;
 use crate::{models::ApiToken, schema::api_tokens};
 use diesel::prelude::*;
+use diesel_async::RunQueryDsl;
 use googletest::prelude::*;
 use http::StatusCode;
 use insta::{assert_json_snapshot, assert_snapshot};
@@ -19,16 +20,19 @@ 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();
+    let mut conn = app.async_db_conn().await;
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
 
     // Ensure that the token currently exists in the database
-    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));
+    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)
+            .await
+    );
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, token.as_model().name);
 
@@ -37,6 +41,7 @@ async fn github_secret_alert_revokes_token() {
     diesel::update(api_tokens::table)
         .set(api_tokens::token.eq(hashed_token))
         .execute(&mut conn)
+        .await
         .unwrap();
 
     let mut request = anon.post_request(URL);
@@ -48,16 +53,22 @@ async fn github_secret_alert_revokes_token() {
     assert_json_snapshot!(response.json());
 
     // Ensure that the token was revoked
-    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));
+    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)
+            .await
+    );
     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));
+    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)
+            .await
+    );
     assert_that!(tokens, len(eq(1)));
 
     // Ensure exactly one email was sent
@@ -67,16 +78,19 @@ 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();
+    let mut conn = app.async_db_conn().await;
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
 
     // Ensure that the token currently exists in the database
-    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));
+    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)
+            .await
+    );
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, token.as_model().name);
 
@@ -88,6 +102,7 @@ async fn github_secret_alert_for_revoked_token() {
             api_tokens::revoked.eq(true),
         ))
         .execute(&mut conn)
+        .await
         .unwrap();
 
     let mut request = anon.post_request(URL);
@@ -99,16 +114,22 @@ async fn github_secret_alert_for_revoked_token() {
     assert_json_snapshot!(response.json());
 
     // Ensure that the token is still revoked
-    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));
+    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)
+            .await
+    );
     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));
+    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)
+            .await
+    );
     assert_that!(tokens, len(eq(1)));
 
     // Ensure still no emails were sent
@@ -118,16 +139,19 @@ 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();
+    let mut conn = app.async_db_conn().await;
 
     // Ensure no emails were sent up to this point
     assert_eq!(app.emails().len(), 0);
 
     // Ensure that the token currently exists in the database
-    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));
+    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)
+            .await
+    );
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, token.as_model().name);
 
@@ -140,10 +164,13 @@ async fn github_secret_alert_for_unknown_token() {
     assert_json_snapshot!(response.json());
 
     // Ensure that the token was not revoked
-    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));
+    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)
+            .await
+    );
     assert_that!(tokens, len(eq(1)));
     assert_eq!(tokens[0].name, token.as_model().name);
 

src/tests/krate/publish/auth.rs

@@ -1,15 +1,16 @@
 use crate::schema::api_tokens;
 use crate::tests::builders::{CrateBuilder, PublishBuilder};
 use crate::tests::util::{RequestHelper, TestApp};
-use diesel::{ExpressionMethods, RunQueryDsl};
+use diesel::ExpressionMethods;
+use diesel_async::RunQueryDsl;
 use googletest::prelude::*;
 use http::StatusCode;
 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();
+    let mut conn = app.async_db_conn().await;
 
     // Try to publish without a token
     let crate_to_publish = PublishBuilder::new("foo", "1.0.0");
@@ -21,6 +22,7 @@ async fn new_wrong_token() {
     diesel::update(api_tokens::table)
         .set(api_tokens::token.eq(b"bad" as &[u8]))
         .execute(&mut conn)
+        .await
         .unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo", "1.0.0");

src/tests/krate/publish/basics.rs

@@ -1,15 +1,16 @@
 use crate::schema::versions_published_by;
 use crate::tests::builders::{CrateBuilder, PublishBuilder};
 use crate::tests::util::{RequestHelper, TestApp};
-use diesel::{QueryDsl, RunQueryDsl};
+use diesel::QueryDsl;
+use diesel_async::RunQueryDsl;
 use googletest::prelude::*;
 use http::StatusCode;
 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 mut conn = app.async_db_conn().await;
 
     let crate_to_publish = PublishBuilder::new("foo_new", "1.0.0");
     let response = user.publish_crate(crate_to_publish).await;
@@ -33,6 +34,7 @@ async fn new_krate() {
     let email: String = versions_published_by::table
         .select(versions_published_by::email)
         .first(&mut conn)
+        .await
         .unwrap();
     assert_eq!(email, "foo@example.com");
 

src/tests/krate/publish/categories.rs

@@ -2,19 +2,21 @@ use crate::tests::builders::PublishBuilder;
 use crate::tests::new_category;
 use crate::tests::util::{RequestHelper, TestApp};
 use crates_io_database::schema::categories;
-use diesel::{insert_into, RunQueryDsl};
+use diesel::insert_into;
+use diesel_async::RunQueryDsl;
 use googletest::prelude::*;
 use http::StatusCode;
 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();
+    let mut conn = app.async_db_conn().await;
 
     insert_into(categories::table)
         .values(new_category("Category 1", "cat1", "Category 1 crates"))
         .execute(&mut conn)
+        .await
         .unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo_good_cat", "1.0.0").category("cat1");

src/tests/krate/publish/emails.rs

@@ -1,17 +1,19 @@
 use crate::schema::emails;
 use crate::tests::builders::PublishBuilder;
 use crate::tests::util::{RequestHelper, TestApp};
-use diesel::{delete, update, ExpressionMethods, RunQueryDsl};
+use diesel::{delete, update, ExpressionMethods};
+use diesel_async::RunQueryDsl;
 use googletest::prelude::*;
+
 use http::StatusCode;
 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();
+    let mut conn = app.async_db_conn().await;
 
-    delete(emails::table).execute(&mut conn).unwrap();
+    delete(emails::table).execute(&mut conn).await.unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo_no_email", "1.0.0");
 
@@ -25,11 +27,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();
+    let mut conn = app.async_db_conn().await;
 
     update(emails::table)
         .set((emails::verified.eq(false),))
         .execute(&mut conn)
+        .await
         .unwrap();
 
     let crate_to_publish = PublishBuilder::new("foo_unverified_email", "1.0.0");