From 28ab113656a8540810b9f77f38b7c9105b10c4b1 Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Fri, 22 Nov 2024 11:27:33 +0100 Subject: [PATCH 1/2] tests/util/test_app: Remove obsolete `db_conn()` fn None of our tests strictly need a sync database connection anymore, and those that were still using one are migrated by this commit to use an async one instead. --- src/tests/issues/issue1205.rs | 5 +- src/tests/issues/issue2736.rs | 12 ++-- src/tests/owners.rs | 9 ++- src/tests/read_only_mode.rs | 5 +- src/tests/routes/categories/get.rs | 33 +++++++---- src/tests/routes/crates/downloads.rs | 20 +++---- src/tests/routes/crates/list.rs | 57 ++++++++++++------- src/tests/routes/crates/owners/remove.rs | 6 +- src/tests/routes/crates/read.rs | 6 +- .../routes/crates/reverse_dependencies.rs | 14 +++-- src/tests/routes/crates/versions/list.rs | 17 +++--- src/tests/routes/crates/versions/read.rs | 7 ++- src/tests/routes/me/email_notifications.rs | 8 ++- src/tests/routes/me/updates.rs | 5 +- src/tests/routes/users/read.rs | 13 +++-- src/tests/routes/users/stats.rs | 16 ++++-- src/tests/team.rs | 28 +++++---- src/tests/util/test_app.rs | 7 --- 18 files changed, 153 insertions(+), 115 deletions(-) diff --git a/src/tests/issues/issue1205.rs b/src/tests/issues/issue1205.rs index 7adf8028e8e..2c05396ceda 100644 --- a/src/tests/issues/issue1205.rs +++ b/src/tests/issues/issue1205.rs @@ -14,7 +14,6 @@ async fn test_issue_1205() -> anyhow::Result<()> { .with_token() .await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let krate = CrateBuilder::new(CRATE_NAME, user.as_model().id) @@ -27,7 +26,7 @@ async fn test_issue_1205() -> anyhow::Result<()> { assert_eq!(response.status(), StatusCode::OK); assert_snapshot!(response.text(), @r#"{"msg":"team github:rustaudio:owners has been added as an owner of crate deepspeech-sys","ok":true}"#); - let owners = krate.owners(&mut conn)?; + let owners = krate.async_owners(&mut async_conn).await?; assert_eq!(owners.len(), 2); assert_eq!(owners[0].login(), "foo"); assert_eq!(owners[1].login(), "github:rustaudio:owners"); @@ -38,7 +37,7 @@ async fn test_issue_1205() -> anyhow::Result<()> { assert_eq!(response.status(), StatusCode::OK); assert_snapshot!(response.text(), @r#"{"msg":"team github:rustaudio:cratesio-push has been added as an owner of crate deepspeech-sys","ok":true}"#); - let owners = krate.owners(&mut conn)?; + let owners = krate.async_owners(&mut async_conn).await?; assert_eq!(owners.len(), 2); assert_eq!(owners[0].login(), "foo"); assert_eq!(owners[1].login(), "github:rustaudio:cratesio-push"); diff --git a/src/tests/issues/issue2736.rs b/src/tests/issues/issue2736.rs index cde3a29e23d..ba1dfad1bcf 100644 --- a/src/tests/issues/issue2736.rs +++ b/src/tests/issues/issue2736.rs @@ -3,6 +3,7 @@ use crate::tests::builders::CrateBuilder; use crate::tests::util::{RequestHelper, TestApp}; use crates_io_database::schema::{crate_owners, users}; use diesel::prelude::*; +use diesel_async::RunQueryDsl; use http::StatusCode; use insta::assert_snapshot; @@ -10,7 +11,6 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_issue_2736() -> anyhow::Result<()> { let (app, _) = TestApp::full().empty().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; // - A user had a GitHub account named, let's say, `foo` @@ -31,7 +31,8 @@ async fn test_issue_2736() -> anyhow::Result<()> { owner_kind: OwnerKind::User, email_notifications: true, }) - .execute(&mut conn)?; + .execute(&mut async_conn) + .await?; // - `foo` deleted their GitHub account (but crates.io has no real knowledge of this) // - `foo` recreated their GitHub account with the same username (because it was still available), but in this situation GitHub assigns them a new ID @@ -41,13 +42,14 @@ async fn test_issue_2736() -> anyhow::Result<()> { let github_ids = users::table .filter(users::gh_login.eq("foo")) .select(users::gh_id) - .load::(&mut conn)?; + .load::(&mut async_conn) + .await?; assert_eq!(github_ids.len(), 2); assert_ne!(github_ids[0], github_ids[1]); // - The new `foo` account is NOT an owner of the crate - let owners = krate.owners(&mut conn)?; + let owners = krate.async_owners(&mut async_conn).await?; assert_eq!(owners.len(), 2); assert_none!(owners.iter().find(|o| o.id() == foo2.as_model().id)); @@ -56,7 +58,7 @@ async fn test_issue_2736() -> anyhow::Result<()> { assert_eq!(response.status(), StatusCode::OK); assert_snapshot!(response.text(), @r#"{"msg":"owners successfully removed","ok":true}"#); - let owners = krate.owners(&mut conn)?; + let owners = krate.async_owners(&mut async_conn).await?; assert_eq!(owners.len(), 1); assert_eq!(owners[0].id(), someone_else.as_model().id); diff --git a/src/tests/owners.rs b/src/tests/owners.rs index 28377182679..665e1fbdc3d 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -218,7 +218,6 @@ async fn owners_can_remove_self() { #[tokio::test(flavor = "multi_thread")] async fn modify_multiple_owners() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let username = &user.as_model().gh_login; @@ -237,7 +236,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!(krate.owners(&mut conn).unwrap().len(), 3); + assert_eq!(krate.async_owners(&mut async_conn).await.unwrap().len(), 3); // Deleting two owners at once is allowed. let response = token @@ -245,7 +244,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!(krate.owners(&mut conn).unwrap().len(), 1); + assert_eq!(krate.async_owners(&mut async_conn).await.unwrap().len(), 1); // Adding multiple users fails if one of them already is an owner. let response = token @@ -253,7 +252,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!(krate.owners(&mut conn).unwrap().len(), 1); + assert_eq!(krate.async_owners(&mut async_conn).await.unwrap().len(), 1); // Adding multiple users at once succeeds. let response = token @@ -271,7 +270,7 @@ async fn modify_multiple_owners() { .accept_ownership_invitation(&krate.name, krate.id) .await; - assert_eq!(krate.owners(&mut conn).unwrap().len(), 3); + assert_eq!(krate.async_owners(&mut async_conn).await.unwrap().len(), 3); } /// Testing the crate ownership between two crates and one team. diff --git a/src/tests/read_only_mode.rs b/src/tests/read_only_mode.rs index bba4bf7e0cd..c90ec04014c 100644 --- a/src/tests/read_only_mode.rs +++ b/src/tests/read_only_mode.rs @@ -2,6 +2,7 @@ use crate::tests::builders::CrateBuilder; use crate::tests::{RequestHelper, TestApp}; use diesel::prelude::*; +use diesel_async::RunQueryDsl; use http::StatusCode; use insta::assert_json_snapshot; @@ -50,7 +51,6 @@ async fn can_download_crate_in_read_only_mode() { .with_user() .await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; CrateBuilder::new("foo_download_read_only", user.as_model().id) @@ -70,6 +70,7 @@ async fn can_download_crate_in_read_only_mode() { let dl_count: Result, _> = version_downloads::table .select(sum(version_downloads::downloads)) - .get_result(&mut conn); + .get_result(&mut async_conn) + .await; assert_ok_eq!(dl_count, None); } diff --git a/src/tests/routes/categories/get.rs b/src/tests/routes/categories/get.rs index 0b56d1d720a..9529a07e8ee 100644 --- a/src/tests/routes/categories/get.rs +++ b/src/tests/routes/categories/get.rs @@ -3,14 +3,15 @@ use crate::tests::builders::CrateBuilder; use crate::tests::new_category; use crate::tests::util::{MockAnonymousUser, RequestHelper, TestApp}; use crates_io_database::schema::categories; -use diesel::{insert_into, RunQueryDsl}; +use diesel::insert_into; +use diesel_async::RunQueryDsl; use insta::assert_json_snapshot; use serde_json::Value; #[tokio::test(flavor = "multi_thread")] async fn show() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.db_conn(); + let mut conn = app.async_db_conn().await; let url = "/api/v1/categories/foo-bar"; @@ -23,9 +24,12 @@ async fn show() { new_category("Foo Bar::Baz", "foo-bar::baz", "Baz crates"), ]; - assert_ok!(insert_into(categories::table) - .values(cats) - .execute(&mut conn)); + assert_ok!( + insert_into(categories::table) + .values(cats) + .execute(&mut conn) + .await + ); // The category and its subcategories should be in the json let json: Value = anon.get(url).await.good(); @@ -44,7 +48,6 @@ async fn update_crate() { } let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -53,9 +56,12 @@ async fn update_crate() { new_category("Category 2", "category-2", "Category 2 crates"), ]; - assert_ok!(insert_into(categories::table) - .values(cats) - .execute(&mut conn)); + assert_ok!( + insert_into(categories::table) + .values(cats) + .execute(&mut async_conn) + .await + ); let krate = CrateBuilder::new("foo_crate", user.id) .expect_build(&mut async_conn) @@ -126,9 +132,12 @@ async fn update_crate() { assert_eq!(count(&anon, "category-2").await, 0); // Add a category and its subcategory - assert_ok!(insert_into(categories::table) - .values(new_category("cat1::bar", "cat1::bar", "bar crates")) - .execute(&mut conn)); + assert_ok!( + insert_into(categories::table) + .values(new_category("cat1::bar", "cat1::bar", "bar crates")) + .execute(&mut async_conn) + .await + ); Category::update_crate(&mut async_conn, krate.id, &["cat1", "cat1::bar"]) .await diff --git a/src/tests/routes/crates/downloads.rs b/src/tests/routes/crates/downloads.rs index 7a7facb2c5d..3fcd4a84c64 100644 --- a/src/tests/routes/crates/downloads.rs +++ b/src/tests/routes/crates/downloads.rs @@ -4,6 +4,7 @@ use crate::tests::util::{MockAnonymousUser, RequestHelper, TestApp}; use crate::views::EncodableVersionDownload; use chrono::{Duration, Utc}; use diesel::prelude::*; +use diesel_async::{AsyncPgConnection, RunQueryDsl}; use http::StatusCode; use insta::{assert_json_snapshot, assert_snapshot}; @@ -12,11 +13,11 @@ struct Downloads { version_downloads: Vec, } -fn save_version_downloads( +async fn save_version_downloads( crate_name: &str, version: &str, num_downloads: i32, - conn: &mut PgConnection, + conn: &mut AsyncPgConnection, ) { let version_id = versions::table .select(versions::id) @@ -24,6 +25,7 @@ fn save_version_downloads( .filter(crates::name.eq(crate_name)) .filter(versions::num.eq(version)) .first::(conn) + .await .unwrap(); diesel::insert_into(version_downloads::table) @@ -32,6 +34,7 @@ fn save_version_downloads( version_downloads::downloads.eq(num_downloads), )) .execute(conn) + .await .unwrap(); } @@ -64,7 +67,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -80,7 +82,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; - save_version_downloads("foo_download", "1.0.0", 1, &mut conn); + save_version_downloads("foo_download", "1.0.0", 1, &mut async_conn).await; // Now that the counters are persisted the download counts show up. assert_dl_count(&anon, "foo_download/1.0.0", None, 1).await; @@ -117,7 +119,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user_id = cookie.as_model().id; @@ -132,8 +133,8 @@ async fn test_crate_downloads() { download(&anon, "foo/1.0.0").await; download(&anon, "foo/1.1.0").await; - save_version_downloads("foo", "1.0.0", 3, &mut conn); - save_version_downloads("foo", "1.1.0", 1, &mut conn); + save_version_downloads("foo", "1.0.0", 3, &mut async_conn).await; + save_version_downloads("foo", "1.1.0", 1, &mut async_conn).await; let response = anon.get::<()>("/api/v1/crates/foo/downloads").await; assert_eq!(response.status(), StatusCode::OK); @@ -159,7 +160,6 @@ async fn test_crate_downloads() { #[tokio::test(flavor = "multi_thread")] async fn test_version_downloads() { let (app, anon, cookie) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user_id = cookie.as_model().id; @@ -174,8 +174,8 @@ async fn test_version_downloads() { download(&anon, "foo/1.0.0").await; download(&anon, "foo/1.1.0").await; - save_version_downloads("foo", "1.0.0", 3, &mut conn); - save_version_downloads("foo", "1.1.0", 1, &mut conn); + save_version_downloads("foo", "1.0.0", 3, &mut async_conn).await; + save_version_downloads("foo", "1.1.0", 1, &mut async_conn).await; 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/list.rs b/src/tests/routes/crates/list.rs index b762376fe83..a3248e058b2 100644 --- a/src/tests/routes/crates/list.rs +++ b/src/tests/routes/crates/list.rs @@ -5,6 +5,7 @@ use crate::tests::util::{RequestHelper, TestApp}; use crate::tests::{new_category, new_user}; use crates_io_database::schema::categories; use diesel::{dsl::*, prelude::*, update}; +use diesel_async::RunQueryDsl; use googletest::prelude::*; use http::StatusCode; use insta::{assert_json_snapshot, assert_snapshot}; @@ -14,7 +15,6 @@ use std::sync::LazyLock; #[tokio::test(flavor = "multi_thread")] async fn index() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; for json in search_both(&anon, "").await { @@ -25,7 +25,8 @@ async fn index() { let user_id = insert_into(users::table) .values(new_user("foo")) .returning(users::id) - .get_result(&mut conn) + .get_result(&mut async_conn) + .await .unwrap(); let krate = CrateBuilder::new("fooindex", user_id) @@ -44,7 +45,6 @@ async fn index() { #[allow(clippy::cognitive_complexity)] async fn index_queries() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -170,7 +170,8 @@ async fn index_queries() { insert_into(categories::table) .values(cats) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); Category::update_crate(&mut async_conn, krate.id, &["cat1"]) @@ -283,7 +284,6 @@ async fn exact_match_first_on_queries() { #[allow(clippy::cognitive_complexity)] async fn index_sorting() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -320,29 +320,35 @@ async fn index_sorting() { // Set the created at column for each crate update(&krate1) .set(crates::created_at.eq(now - 4.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate2) .set(crates::created_at.eq(now - 1.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .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) + .execute(&mut async_conn) + .await .unwrap(); // Set the updated at column for each crate update(&krate1) .set(crates::updated_at.eq(now - 3.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .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) + .execute(&mut async_conn) + .await .unwrap(); update(&krate4) .set(crates::updated_at.eq(now)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); // Sort by downloads @@ -508,7 +514,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -542,37 +547,45 @@ async fn ignore_exact_match_on_queries_with_sort() { // Set the created at column for each crate update(&krate1) .set(crates::created_at.eq(now - 4.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate2) .set(crates::created_at.eq(now - 1.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate3) .set(crates::created_at.eq(now - 2.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate4) .set(crates::created_at.eq(now - 3.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); // Set the updated at column for each crate update(&krate1) .set(crates::updated_at.eq(now - 3.weeks())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate2) .set(crates::updated_at.eq(now - 5.days())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate3) .set(crates::updated_at.eq(now - 10.seconds())) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); update(&krate4) .set(crates::updated_at.eq(now)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); // Sort by downloads, order always the same no matter the crate name query @@ -908,7 +921,6 @@ async fn test_zero_downloads() { #[tokio::test(flavor = "multi_thread")] async fn test_default_sort_recent() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -946,7 +958,8 @@ async fn test_default_sort_recent() { insert_into(categories::table) .values(new_category("Animal", "animal", "animal crates")) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); Category::update_crate(&mut async_conn, green_crate.id, &["animal"]) diff --git a/src/tests/routes/crates/owners/remove.rs b/src/tests/routes/crates/owners/remove.rs index f48b2fdbeda..051287a0c75 100644 --- a/src/tests/routes/crates/owners/remove.rs +++ b/src/tests/routes/crates/owners/remove.rs @@ -83,11 +83,10 @@ async fn test_unknown_team() { #[tokio::test(flavor = "multi_thread")] async fn test_remove_uppercase_user() { - use diesel::RunQueryDsl; + use diesel_async::RunQueryDsl; let (app, _, cookie) = TestApp::full().with_user().await; let user2 = app.db_new_user("user2").await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let krate = CrateBuilder::new("foo", cookie.as_model().id) @@ -102,7 +101,8 @@ async fn test_remove_uppercase_user() { owner_kind: OwnerKind::User, email_notifications: true, }) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let response = cookie.remove_named_owner("foo", "USER2").await; diff --git a/src/tests/routes/crates/read.rs b/src/tests/routes/crates/read.rs index 508dd43c9a5..b13a3a121e6 100644 --- a/src/tests/routes/crates/read.rs +++ b/src/tests/routes/crates/read.rs @@ -1,13 +1,12 @@ use crate::tests::builders::{CrateBuilder, PublishBuilder, VersionBuilder}; use crate::tests::util::{RequestHelper, TestApp}; -use diesel::prelude::*; +use diesel_async::RunQueryDsl; use http::StatusCode; use insta::{assert_json_snapshot, assert_snapshot}; #[tokio::test(flavor = "multi_thread")] async fn show() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -33,7 +32,8 @@ async fn show() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let response = anon.get::<()>("/api/v1/crates/foo_show").await; diff --git a/src/tests/routes/crates/reverse_dependencies.rs b/src/tests/routes/crates/reverse_dependencies.rs index c67cb7426b3..a645cd646cb 100644 --- a/src/tests/routes/crates/reverse_dependencies.rs +++ b/src/tests/routes/crates/reverse_dependencies.rs @@ -132,7 +132,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -157,11 +156,13 @@ async fn yanked_versions_not_included_in_reverse_dependencies() { }); use crate::schema::versions; - use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl}; + use diesel::{ExpressionMethods, QueryDsl}; + use diesel_async::RunQueryDsl; diesel::update(versions::table.filter(versions::num.eq("2.0.0"))) .set(versions::yanked.eq(true)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let response = anon @@ -177,12 +178,12 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); use crate::schema::versions; - use diesel::{update, ExpressionMethods, RunQueryDsl}; + use diesel::{update, ExpressionMethods}; + use diesel_async::RunQueryDsl; let c1 = CrateBuilder::new("c1", user.id) .version("1.0.0") @@ -198,7 +199,8 @@ async fn reverse_dependencies_includes_published_by_user_when_present() { let none: Option = None; update(versions::table) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); // c3's version will have the published by info recorded diff --git a/src/tests/routes/crates/versions/list.rs b/src/tests/routes/crates/versions/list.rs index 5911667ee9e..7ef928efac5 100644 --- a/src/tests/routes/crates/versions/list.rs +++ b/src/tests/routes/crates/versions/list.rs @@ -3,6 +3,7 @@ use crate::tests::builders::{CrateBuilder, VersionBuilder}; use crate::tests::util::{RequestHelper, TestApp}; use crate::views::EncodableVersion; use diesel::{prelude::*, update}; +use diesel_async::RunQueryDsl; use googletest::prelude::*; use http::StatusCode; use insta::{assert_json_snapshot, assert_snapshot}; @@ -11,7 +12,6 @@ use serde_json::json; #[tokio::test(flavor = "multi_thread")] async fn versions() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -28,7 +28,8 @@ async fn versions() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let response = anon.get::<()>("/api/v1/crates/foo_versions/versions").await; @@ -51,7 +52,6 @@ async fn test_unknown_crate() { #[tokio::test(flavor = "multi_thread")] async fn test_sorting() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -84,7 +84,8 @@ async fn test_sorting() { 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) + .execute(&mut async_conn) + .await .unwrap(); // An additional crate to guarantee the accuracy of the response dataset and its total @@ -155,7 +156,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -172,7 +172,8 @@ async fn test_seek_based_pagination_semver_sorting() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let url = "/api/v1/crates/foo_versions/versions"; @@ -240,7 +241,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -257,7 +257,8 @@ async fn test_seek_based_pagination_date_sorting() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let url = "/api/v1/crates/foo_versions/versions"; diff --git a/src/tests/routes/crates/versions/read.rs b/src/tests/routes/crates/versions/read.rs index b303a8a4c13..c6a74dcbfc3 100644 --- a/src/tests/routes/crates/versions/read.rs +++ b/src/tests/routes/crates/versions/read.rs @@ -2,6 +2,7 @@ use crate::tests::builders::{CrateBuilder, VersionBuilder}; use crate::tests::util::insta::{self, assert_json_snapshot}; use crate::tests::util::{RequestHelper, TestApp}; use diesel::prelude::*; +use diesel_async::RunQueryDsl; use serde_json::Value; #[tokio::test(flavor = "multi_thread")] @@ -33,10 +34,9 @@ async fn show_by_crate_name_and_version() { #[tokio::test(flavor = "multi_thread")] async fn show_by_crate_name_and_semver_no_published_by() { use crate::schema::versions; - use diesel::{update, RunQueryDsl}; + use diesel::update; let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); @@ -51,7 +51,8 @@ async fn show_by_crate_name_and_semver_no_published_by() { let none: Option = None; update(versions::table) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let url = "/api/v1/crates/foo_vers_show_no_pb/1.0.0"; diff --git a/src/tests/routes/me/email_notifications.rs b/src/tests/routes/me/email_notifications.rs index 7a225f82b02..4fb9effb7ae 100644 --- a/src/tests/routes/me/email_notifications.rs +++ b/src/tests/routes/me/email_notifications.rs @@ -3,6 +3,7 @@ use crate::tests::builders::CrateBuilder; use crate::tests::new_user; use crate::tests::util::{RequestHelper, TestApp}; use diesel::prelude::*; +use diesel_async::RunQueryDsl; use http::StatusCode; use serde_json::json; @@ -112,13 +113,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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user_id = diesel::insert_into(users::table) .values(new_user("arbitrary_username")) .returning(users::id) - .get_result(&mut conn) + .get_result(&mut async_conn) + .await .unwrap(); let not_my_crate = CrateBuilder::new("test_package", user_id) @@ -134,7 +135,8 @@ async fn test_update_email_notifications_not_owned() { 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) + .first(&mut async_conn) + .await .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/updates.rs b/src/tests/routes/me/updates.rs index 80319a12532..6f67ea99a84 100644 --- a/src/tests/routes/me/updates.rs +++ b/src/tests/routes/me/updates.rs @@ -5,6 +5,7 @@ use crate::tests::OkBool; use crate::views::EncodableVersion; use diesel::prelude::*; use diesel::update; +use diesel_async::RunQueryDsl; use googletest::prelude::*; use http::StatusCode; use insta::assert_snapshot; @@ -28,7 +29,6 @@ async fn following() { } let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user_model = user.as_model(); let user_id = user_model.id; @@ -43,7 +43,8 @@ async fn following() { let none: Option = None; update(versions::table) .set(versions::published_by.eq(none)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); CrateBuilder::new("bar_fighters", user_id) diff --git a/src/tests/routes/users/read.rs b/src/tests/routes/users/read.rs index 3ae642ec5da..c8f2d75daec 100644 --- a/src/tests/routes/users/read.rs +++ b/src/tests/routes/users/read.rs @@ -2,7 +2,7 @@ use crate::models::NewUser; use crate::schema::users; use crate::tests::util::{RequestHelper, TestApp}; use crate::views::EncodablePublicUser; -use diesel::RunQueryDsl; +use diesel_async::RunQueryDsl; #[derive(Deserialize)] pub struct UserShowPublicResponse { @@ -25,7 +25,7 @@ async fn show() { #[tokio::test(flavor = "multi_thread")] async fn show_latest_user_case_insensitively() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.db_conn(); + let mut conn = app.async_db_conn().await; // 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 @@ -51,9 +51,12 @@ async fn show_latest_user_case_insensitively() { "bar", ); - assert_ok!(diesel::insert_into(users::table) - .values(&vec![user1, user2]) - .execute(&mut conn)); + assert_ok!( + diesel::insert_into(users::table) + .values(&vec![user1, user2]) + .execute(&mut conn) + .await + ); 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 959a81ad1e2..5128785daed 100644 --- a/src/tests/routes/users/stats.rs +++ b/src/tests/routes/users/stats.rs @@ -11,10 +11,10 @@ async fn user_total_downloads() { use crate::tests::builders::CrateBuilder; use crate::tests::util::{RequestHelper, TestApp}; use diesel::prelude::*; - use diesel::{update, QueryDsl, RunQueryDsl}; + use diesel::{update, QueryDsl}; + use diesel_async::RunQueryDsl; let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = user.as_model(); let another_user = app.db_new_user("bar").await; @@ -25,7 +25,8 @@ async fn user_total_downloads() { .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate.id))) .set(crate_downloads::downloads.eq(10)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let krate2 = CrateBuilder::new("foo_krate2", user.id) @@ -33,7 +34,8 @@ async fn user_total_downloads() { .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate2.id))) .set(crate_downloads::downloads.eq(20)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let another_krate = CrateBuilder::new("bar_krate1", another_user.id) @@ -41,7 +43,8 @@ async fn user_total_downloads() { .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(another_krate.id))) .set(crate_downloads::downloads.eq(2)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); let no_longer_my_krate = CrateBuilder::new("nacho", user.id) @@ -49,7 +52,8 @@ async fn user_total_downloads() { .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(no_longer_my_krate.id))) .set(crate_downloads::downloads.eq(5)) - .execute(&mut conn) + .execute(&mut async_conn) + .await .unwrap(); no_longer_my_krate .owner_remove(&mut async_conn, &user.gh_login) diff --git a/src/tests/team.rs b/src/tests/team.rs index abc5a11f29b..723f5c1308d 100644 --- a/src/tests/team.rs +++ b/src/tests/team.rs @@ -9,6 +9,7 @@ use crate::{ }; use diesel::*; +use diesel_async::RunQueryDsl; use http::StatusCode; use insta::assert_snapshot; @@ -92,7 +93,6 @@ async fn add_nonexistent_team() { #[tokio::test(flavor = "multi_thread")] async fn add_renamed_team() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = app.db_new_user("user-all-teams").await; let token = user.db_new_token("arbitrary token name").await; @@ -121,7 +121,11 @@ async fn add_renamed_team() { .unwrap(); assert_eq!( - teams::table.count().get_result::(&mut conn).unwrap(), + teams::table + .count() + .get_result::(&mut async_conn) + .await + .unwrap(), 1 ); @@ -139,7 +143,6 @@ async fn add_renamed_team() { #[tokio::test(flavor = "multi_thread")] async fn add_team_mixed_case() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = app.db_new_user("user-all-teams").await; let token = user.db_new_token("arbitrary token name").await; @@ -153,8 +156,11 @@ async fn add_team_mixed_case() { .await .good(); - let krate: Crate = Crate::by_name("foo_mixed_case").first(&mut conn).unwrap(); - let owners = krate.owners(&mut conn).unwrap(); + let krate: Crate = Crate::by_name("foo_mixed_case") + .first(&mut async_conn) + .await + .unwrap(); + let owners = krate.async_owners(&mut async_conn).await.unwrap(); assert_eq!(owners.len(), 2); let owner = &owners[1]; assert_eq!(owner.login(), owner.login().to_lowercase()); @@ -167,7 +173,6 @@ async fn add_team_mixed_case() { #[tokio::test(flavor = "multi_thread")] async fn add_team_as_org_owner() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; let user = app.db_new_user("user-org-owner").await; let token = user.db_new_token("arbitrary token name").await; @@ -181,8 +186,11 @@ async fn add_team_as_org_owner() { .await .good(); - let krate: Crate = Crate::by_name("foo_org_owner").first(&mut conn).unwrap(); - let owners = krate.owners(&mut conn).unwrap(); + let krate: Crate = Crate::by_name("foo_org_owner") + .first(&mut async_conn) + .await + .unwrap(); + let owners = krate.async_owners(&mut async_conn).await.unwrap(); assert_eq!(owners.len(), 2); let owner = &owners[1]; assert_eq!(owner.login(), owner.login().to_lowercase()); @@ -289,7 +297,6 @@ 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().await; - let mut conn = app.db_conn(); let mut async_conn = app.async_db_conn().await; CrateBuilder::new("foo_remove_nonexistent", user.as_model().id) @@ -300,7 +307,8 @@ async fn remove_nonexistent_team() { teams::login.eq("github:test-org:this-does-not-exist"), teams::github_id.eq(5678), )) - .execute(&mut conn) + .execute(&mut async_conn) + .await .expect("couldn't insert nonexistent team"); let response = token diff --git a/src/tests/util/test_app.rs b/src/tests/util/test_app.rs index ada6c1aba56..b17ea988e98 100644 --- a/src/tests/util/test_app.rs +++ b/src/tests/util/test_app.rs @@ -18,8 +18,6 @@ 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 diesel_async::AsyncPgConnection; use futures_util::TryStreamExt; use oauth2::{ClientId, ClientSecret}; @@ -112,11 +110,6 @@ impl TestApp { Self::init().with_git_index().with_job_runner() } - /// Obtain a database connection. - pub fn db_conn(&self) -> PooledConnection> { - self.0.test_database.connect() - } - /// Obtain an async database connection from the primary database pool. pub async fn async_db_conn(&self) -> AsyncPgConnection { self.0.test_database.async_connect().await From c49bf694ccae17c8e664ea1e74313278c9adbba0 Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Fri, 22 Nov 2024 11:30:06 +0100 Subject: [PATCH 2/2] tests/util/test_app: Rename `async_db_conn()` fn to `db_conn()` We only use async connections from now on, so there is no need for the `async_` prefix anymore --- src/tests/account_lock.rs | 2 +- src/tests/blocked_routes.rs | 4 +- src/tests/dump_db.rs | 2 +- src/tests/github_secret_scanning.rs | 6 +- src/tests/issues/issue1205.rs | 8 +- src/tests/issues/issue2736.rs | 12 +- src/tests/krate/following.rs | 6 +- src/tests/krate/publish/audit_action.rs | 2 +- src/tests/krate/publish/auth.rs | 4 +- src/tests/krate/publish/basics.rs | 4 +- src/tests/krate/publish/categories.rs | 2 +- src/tests/krate/publish/deleted_crates.rs | 2 +- src/tests/krate/publish/dependencies.rs | 28 ++--- src/tests/krate/publish/emails.rs | 4 +- src/tests/krate/publish/features.rs | 6 +- src/tests/krate/publish/max_size.rs | 2 +- src/tests/krate/publish/rate_limit.rs | 8 +- src/tests/krate/publish/readme.rs | 2 +- src/tests/krate/publish/similar_names.rs | 6 +- src/tests/krate/publish/timestamps.rs | 2 +- src/tests/krate/yanking.rs | 4 +- src/tests/owners.rs | 53 ++++---- src/tests/pagination.rs | 2 +- src/tests/read_only_mode.rs | 8 +- src/tests/routes/categories/get.rs | 33 +++-- src/tests/routes/categories/list.rs | 2 +- src/tests/routes/category_slugs/list.rs | 2 +- src/tests/routes/crates/downloads.rs | 24 ++-- src/tests/routes/crates/following.rs | 2 +- src/tests/routes/crates/list.rs | 116 +++++++++--------- src/tests/routes/crates/owners/add.rs | 32 ++--- src/tests/routes/crates/owners/remove.rs | 14 +-- src/tests/routes/crates/read.rs | 14 +-- .../routes/crates/reverse_dependencies.rs | 28 ++--- src/tests/routes/crates/versions/authors.rs | 2 +- .../routes/crates/versions/dependencies.rs | 2 +- src/tests/routes/crates/versions/download.rs | 4 +- src/tests/routes/crates/versions/list.rs | 28 ++--- src/tests/routes/crates/versions/read.rs | 10 +- .../routes/crates/versions/yank_unyank.rs | 6 +- src/tests/routes/keywords/list.rs | 2 +- src/tests/routes/keywords/read.rs | 6 +- src/tests/routes/me/email_notifications.rs | 10 +- src/tests/routes/me/get.rs | 8 +- src/tests/routes/me/tokens/create.rs | 8 +- src/tests/routes/me/tokens/delete.rs | 4 +- src/tests/routes/me/tokens/delete_current.rs | 4 +- src/tests/routes/me/tokens/get.rs | 4 +- src/tests/routes/me/tokens/list.rs | 6 +- src/tests/routes/me/updates.rs | 8 +- .../routes/private/crate_owner_invitations.rs | 8 +- src/tests/routes/summary.rs | 6 +- src/tests/routes/users/read.rs | 2 +- src/tests/routes/users/stats.rs | 20 +-- src/tests/server.rs | 6 +- src/tests/team.rs | 102 ++++++++------- src/tests/token.rs | 2 +- src/tests/unhealthy_database.rs | 2 +- src/tests/user.rs | 10 +- src/tests/util.rs | 2 +- src/tests/util/test_app.rs | 4 +- src/tests/version.rs | 4 +- src/tests/worker/git.rs | 2 +- src/tests/worker/rss/sync_crate_feed.rs | 2 +- src/tests/worker/rss/sync_crates_feed.rs | 2 +- src/tests/worker/rss/sync_updates_feed.rs | 2 +- src/tests/worker/sync_admins.rs | 2 +- 67 files changed, 363 insertions(+), 373 deletions(-) diff --git a/src/tests/account_lock.rs b/src/tests/account_lock.rs index fa591a90421..c40606a5913 100644 --- a/src/tests/account_lock.rs +++ b/src/tests/account_lock.rs @@ -11,7 +11,7 @@ async fn lock_account(app: &TestApp, user_id: i32, until: Option) use diesel::prelude::*; use diesel_async::RunQueryDsl; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; diesel::update(users::table) .set(( diff --git a/src/tests/blocked_routes.rs b/src/tests/blocked_routes.rs index 0b9a5928d50..7c1e31efddb 100644 --- a/src/tests/blocked_routes.rs +++ b/src/tests/blocked_routes.rs @@ -11,7 +11,7 @@ async fn test_non_blocked_download_route() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", user.as_model().id) .version(VersionBuilder::new("1.0.0")) @@ -37,7 +37,7 @@ async fn test_blocked_download_route() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", user.as_model().id) .version(VersionBuilder::new("1.0.0")) diff --git a/src/tests/dump_db.rs b/src/tests/dump_db.rs index 076f325f112..898529cf130 100644 --- a/src/tests/dump_db.rs +++ b/src/tests/dump_db.rs @@ -16,7 +16,7 @@ static PATH_DATE_RE: LazyLock = #[tokio::test(flavor = "multi_thread")] async fn test_dump_db_job() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("test-crate", token.as_model().user_id) .expect_build(&mut conn) diff --git a/src/tests/github_secret_scanning.rs b/src/tests/github_secret_scanning.rs index 81a5fbe69ab..77dd2f635ad 100644 --- a/src/tests/github_secret_scanning.rs +++ b/src/tests/github_secret_scanning.rs @@ -45,7 +45,7 @@ async fn github_secret_alert_revokes_token() { .with_github(github_mock()) .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Ensure no emails were sent up to this point assert_eq!(app.emails().await.len(), 0); @@ -106,7 +106,7 @@ async fn github_secret_alert_for_revoked_token() { .with_github(github_mock()) .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Ensure no emails were sent up to this point assert_eq!(app.emails().await.len(), 0); @@ -170,7 +170,7 @@ async fn github_secret_alert_for_unknown_token() { .with_github(github_mock()) .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Ensure no emails were sent up to this point assert_eq!(app.emails().await.len(), 0); diff --git a/src/tests/issues/issue1205.rs b/src/tests/issues/issue1205.rs index 2c05396ceda..afaeb290498 100644 --- a/src/tests/issues/issue1205.rs +++ b/src/tests/issues/issue1205.rs @@ -14,10 +14,10 @@ async fn test_issue_1205() -> anyhow::Result<()> { .with_token() .await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let krate = CrateBuilder::new(CRATE_NAME, user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = user @@ -26,7 +26,7 @@ async fn test_issue_1205() -> anyhow::Result<()> { assert_eq!(response.status(), StatusCode::OK); assert_snapshot!(response.text(), @r#"{"msg":"team github:rustaudio:owners has been added as an owner of crate deepspeech-sys","ok":true}"#); - let owners = krate.async_owners(&mut async_conn).await?; + let owners = krate.async_owners(&mut conn).await?; assert_eq!(owners.len(), 2); assert_eq!(owners[0].login(), "foo"); assert_eq!(owners[1].login(), "github:rustaudio:owners"); @@ -37,7 +37,7 @@ async fn test_issue_1205() -> anyhow::Result<()> { assert_eq!(response.status(), StatusCode::OK); assert_snapshot!(response.text(), @r#"{"msg":"team github:rustaudio:cratesio-push has been added as an owner of crate deepspeech-sys","ok":true}"#); - let owners = krate.async_owners(&mut async_conn).await?; + let owners = krate.async_owners(&mut conn).await?; assert_eq!(owners.len(), 2); assert_eq!(owners[0].login(), "foo"); assert_eq!(owners[1].login(), "github:rustaudio:cratesio-push"); diff --git a/src/tests/issues/issue2736.rs b/src/tests/issues/issue2736.rs index ba1dfad1bcf..95549adede0 100644 --- a/src/tests/issues/issue2736.rs +++ b/src/tests/issues/issue2736.rs @@ -11,7 +11,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_issue_2736() -> anyhow::Result<()> { let (app, _) = TestApp::full().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // - A user had a GitHub account named, let's say, `foo` let foo1 = app.db_new_user("foo").await; @@ -20,7 +20,7 @@ async fn test_issue_2736() -> anyhow::Result<()> { let someone_else = app.db_new_user("someone_else").await; let krate = CrateBuilder::new("crate1", someone_else.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; diesel::insert_into(crate_owners::table) @@ -31,7 +31,7 @@ async fn test_issue_2736() -> anyhow::Result<()> { owner_kind: OwnerKind::User, email_notifications: true, }) - .execute(&mut async_conn) + .execute(&mut conn) .await?; // - `foo` deleted their GitHub account (but crates.io has no real knowledge of this) @@ -42,14 +42,14 @@ async fn test_issue_2736() -> anyhow::Result<()> { let github_ids = users::table .filter(users::gh_login.eq("foo")) .select(users::gh_id) - .load::(&mut async_conn) + .load::(&mut conn) .await?; assert_eq!(github_ids.len(), 2); assert_ne!(github_ids[0], github_ids[1]); // - The new `foo` account is NOT an owner of the crate - let owners = krate.async_owners(&mut async_conn).await?; + let owners = krate.async_owners(&mut conn).await?; assert_eq!(owners.len(), 2); assert_none!(owners.iter().find(|o| o.id() == foo2.as_model().id)); @@ -58,7 +58,7 @@ async fn test_issue_2736() -> anyhow::Result<()> { assert_eq!(response.status(), StatusCode::OK); assert_snapshot!(response.text(), @r#"{"msg":"owners successfully removed","ok":true}"#); - let owners = krate.async_owners(&mut async_conn).await?; + let owners = krate.async_owners(&mut conn).await?; assert_eq!(owners.len(), 1); assert_eq!(owners[0].id(), someone_else.as_model().id); diff --git a/src/tests/krate/following.rs b/src/tests/krate/following.rs index e48e83ea5d9..4bb97fcad76 100644 --- a/src/tests/krate/following.rs +++ b/src/tests/krate/following.rs @@ -34,7 +34,7 @@ async fn test_unauthenticated_requests() { const CRATE_NAME: &str = "foo"; let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new(CRATE_NAME, user.as_model().id) .expect_build(&mut conn) @@ -64,7 +64,7 @@ async fn test_following() { const CRATE_NAME: &str = "foo_following"; let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new(CRATE_NAME, user.as_model().id) .expect_build(&mut conn) @@ -122,7 +122,7 @@ async fn test_api_token_auth() { const CRATE_NOT_TO_FOLLOW: &str = "another_crate"; let (app, _, user, token) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let api_token = token.as_model(); CrateBuilder::new(CRATE_TO_FOLLOW, api_token.user_id) diff --git a/src/tests/krate/publish/audit_action.rs b/src/tests/krate/publish/audit_action.rs index e7732f301e2..9c8de6e101a 100644 --- a/src/tests/krate/publish/audit_action.rs +++ b/src/tests/krate/publish/audit_action.rs @@ -8,7 +8,7 @@ async fn publish_records_an_audit_action() { let (app, anon, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; assert!(VersionOwnerAction::all(&mut conn).await.unwrap().is_empty()); // Upload a new crate, putting it in the git index diff --git a/src/tests/krate/publish/auth.rs b/src/tests/krate/publish/auth.rs index cf866bbc693..98c728c5045 100644 --- a/src/tests/krate/publish/auth.rs +++ b/src/tests/krate/publish/auth.rs @@ -10,7 +10,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn new_wrong_token() { let (app, anon, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Try to publish without a token let crate_to_publish = PublishBuilder::new("foo", "1.0.0"); @@ -36,7 +36,7 @@ async fn new_wrong_token() { #[tokio::test(flavor = "multi_thread")] async fn new_krate_wrong_user() { let (app, _, user) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Create the foo_wrong crate with one user CrateBuilder::new("foo_wrong", user.as_model().id) diff --git a/src/tests/krate/publish/basics.rs b/src/tests/krate/publish/basics.rs index 820ecd65388..1e929f19ebe 100644 --- a/src/tests/krate/publish/basics.rs +++ b/src/tests/krate/publish/basics.rs @@ -10,7 +10,7 @@ use insta::{assert_json_snapshot, assert_snapshot}; #[tokio::test(flavor = "multi_thread")] async fn new_krate() { let (app, _, user) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let crate_to_publish = PublishBuilder::new("foo_new", "1.0.0"); let response = user.publish_crate(crate_to_publish).await; @@ -146,7 +146,7 @@ async fn new_krate_twice_alt() { #[tokio::test(flavor = "multi_thread")] async fn new_krate_duplicate_version() { let (app, _, user, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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) diff --git a/src/tests/krate/publish/categories.rs b/src/tests/krate/publish/categories.rs index 31c4cbb48aa..36f4e397682 100644 --- a/src/tests/krate/publish/categories.rs +++ b/src/tests/krate/publish/categories.rs @@ -11,7 +11,7 @@ use insta::{assert_json_snapshot, assert_snapshot}; #[tokio::test(flavor = "multi_thread")] async fn good_categories() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; insert_into(categories::table) .values(new_category("Category 1", "cat1", "Category 1 crates")) diff --git a/src/tests/krate/publish/deleted_crates.rs b/src/tests/krate/publish/deleted_crates.rs index b9fd2efc7c4..7fda17c508b 100644 --- a/src/tests/krate/publish/deleted_crates.rs +++ b/src/tests/krate/publish/deleted_crates.rs @@ -11,7 +11,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_recently_deleted_crate_with_same_name() -> anyhow::Result<()> { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let now = Utc::now(); let created_at = now - Duration::hours(24); diff --git a/src/tests/krate/publish/dependencies.rs b/src/tests/krate/publish/dependencies.rs index d9b92a057e8..cc6682a4342 100644 --- a/src/tests/krate/publish/dependencies.rs +++ b/src/tests/krate/publish/dependencies.rs @@ -19,7 +19,7 @@ async fn invalid_dependency_name() { #[tokio::test(flavor = "multi_thread")] async fn new_with_renamed_dependency() { let (app, _, user, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -38,7 +38,7 @@ async fn new_with_renamed_dependency() { #[tokio::test(flavor = "multi_thread")] async fn invalid_dependency_rename() { let (app, _, user, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -59,7 +59,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -80,7 +80,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -101,7 +101,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -122,7 +122,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -143,7 +143,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new-krate can depend on it CrateBuilder::new("package-name", user.as_model().id) @@ -164,7 +164,7 @@ async fn new_krate_with_dependency() { use crate::tests::routes::crates::versions::dependencies::Deps; let (app, anon, user, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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 @@ -197,7 +197,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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 @@ -219,7 +219,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo-dep", user.as_model().id) .expect_build(&mut conn) @@ -239,7 +239,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo-dep", user.as_model().id) .expect_build(&mut conn) @@ -268,7 +268,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that new_wild can depend on it CrateBuilder::new("foo_wild", user.as_model().id) @@ -303,7 +303,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert crates directly into the database so that two-deps can depend on it CrateBuilder::new("dep-a", user.as_model().id) @@ -348,7 +348,7 @@ async fn test_dep_limit() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("dep-a", user.as_model().id) .expect_build(&mut conn) diff --git a/src/tests/krate/publish/emails.rs b/src/tests/krate/publish/emails.rs index c8dcc776e6f..0e06a6a0067 100644 --- a/src/tests/krate/publish/emails.rs +++ b/src/tests/krate/publish/emails.rs @@ -11,7 +11,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn new_krate_without_any_email_fails() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; delete(emails::table).execute(&mut conn).await.unwrap(); @@ -27,7 +27,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; update(emails::table) .set((emails::verified.eq(false),)) diff --git a/src/tests/krate/publish/features.rs b/src/tests/krate/publish/features.rs index 88079d4bc2a..d0bf2596226 100644 --- a/src/tests/krate/publish/features.rs +++ b/src/tests/krate/publish/features.rs @@ -7,7 +7,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Insert a crate directly into the database so that foo_new can depend on it CrateBuilder::new("bar", user.as_model().id) @@ -127,7 +127,7 @@ async fn too_many_features_with_custom_limit() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", user.as_model().id) .max_features(4) @@ -187,7 +187,7 @@ async fn too_many_enabled_features_with_custom_limit() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", user.as_model().id) .max_features(4) diff --git a/src/tests/krate/publish/max_size.rs b/src/tests/krate/publish/max_size.rs index 563134b4cb1..0ae2df8ea82 100644 --- a/src/tests/krate/publish/max_size.rs +++ b/src/tests/krate/publish/max_size.rs @@ -136,7 +136,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_whitelist", user.as_model().id) .max_upload_size(2_000_000) diff --git a/src/tests/krate/publish/rate_limit.rs b/src/tests/krate/publish/rate_limit.rs index 67676e4ba23..2adffa18cde 100644 --- a/src/tests/krate/publish/rate_limit.rs +++ b/src/tests/krate/publish/rate_limit.rs @@ -17,7 +17,7 @@ async fn publish_new_crate_ratelimit_hit() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Set up the database so it'll think we've massively ratelimited ourselves @@ -53,7 +53,7 @@ async fn publish_new_crate_ratelimit_expires() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Set up the database so it'll think we've massively ratelimited ourselves @@ -97,7 +97,7 @@ async fn publish_new_crate_override_loosens_ratelimit() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Add an override so our user gets *2* new tokens (expires, y'know, sometime) diesel::insert_into(publish_rate_overrides::table) @@ -175,7 +175,7 @@ async fn publish_new_crate_expired_override_ignored() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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); diff --git a/src/tests/krate/publish/readme.rs b/src/tests/krate/publish/readme.rs index f217398f842..796299d3e34 100644 --- a/src/tests/krate/publish/readme.rs +++ b/src/tests/krate/publish/readme.rs @@ -71,7 +71,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); // 1. Start with a crate with no documentation diff --git a/src/tests/krate/publish/similar_names.rs b/src/tests/krate/publish/similar_names.rs index 43dadbbb543..b0e773a0a34 100644 --- a/src/tests/krate/publish/similar_names.rs +++ b/src/tests/krate/publish/similar_names.rs @@ -7,7 +7,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn new_crate_similar_name() { let (app, _, user, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("Foo_similar", user.as_model().id) .version("1.0.0") @@ -24,7 +24,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_bar_hyphen", user.as_model().id) .version("1.0.0") @@ -41,7 +41,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo-bar-underscore", user.as_model().id) .version("1.0.0") diff --git a/src/tests/krate/publish/timestamps.rs b/src/tests/krate/publish/timestamps.rs index 74bee7e8daa..98139be1f58 100644 --- a/src/tests/krate/publish/timestamps.rs +++ b/src/tests/krate/publish/timestamps.rs @@ -9,7 +9,7 @@ async fn uploading_new_version_touches_crate() { use diesel_async::RunQueryDsl; let (app, _, user) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let crate_to_publish = PublishBuilder::new("foo_versions_updated_at", "1.0.0"); user.publish_crate(crate_to_publish).await.good(); diff --git a/src/tests/krate/yanking.rs b/src/tests/krate/yanking.rs index b09d0dc5a66..dbae08818c4 100644 --- a/src/tests/krate/yanking.rs +++ b/src/tests/krate/yanking.rs @@ -84,7 +84,7 @@ async fn yank_ratelimit_hit() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Set up the database so it'll think we've massively rate-limited ourselves. @@ -121,7 +121,7 @@ async fn yank_ratelimit_expires() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Set up the database so it'll think we've massively ratelimited ourselves diff --git a/src/tests/owners.rs b/src/tests/owners.rs index 665e1fbdc3d..374b2b42052 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -129,7 +129,7 @@ impl MockAnonymousUser { #[tokio::test(flavor = "multi_thread")] async fn new_crate_owner() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Create a crate under one user let crate_to_publish = PublishBuilder::new("foo_owner", "1.0.0"); @@ -183,7 +183,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let username = &user.as_model().gh_login; let krate = CrateBuilder::new("owners_selfremove", user.as_model().id) @@ -218,11 +218,11 @@ async fn owners_can_remove_self() { #[tokio::test(flavor = "multi_thread")] async fn modify_multiple_owners() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let username = &user.as_model().gh_login; let krate = CrateBuilder::new("owners_multiple", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let user2 = create_and_add_owner(&app, &token, "user2", &krate).await; @@ -236,7 +236,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!(krate.async_owners(&mut async_conn).await.unwrap().len(), 3); + assert_eq!(krate.async_owners(&mut conn).await.unwrap().len(), 3); // Deleting two owners at once is allowed. let response = token @@ -244,7 +244,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!(krate.async_owners(&mut async_conn).await.unwrap().len(), 1); + assert_eq!(krate.async_owners(&mut conn).await.unwrap().len(), 1); // Adding multiple users fails if one of them already is an owner. let response = token @@ -252,7 +252,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!(krate.async_owners(&mut async_conn).await.unwrap().len(), 1); + assert_eq!(krate.async_owners(&mut conn).await.unwrap().len(), 1); // Adding multiple users at once succeeds. let response = token @@ -270,7 +270,7 @@ async fn modify_multiple_owners() { .accept_ownership_invitation(&krate.name, krate.id) .await; - assert_eq!(krate.async_owners(&mut async_conn).await.unwrap().len(), 3); + assert_eq!(krate.async_owners(&mut conn).await.unwrap().len(), 3); } /// Testing the crate ownership between two crates and one team. @@ -282,7 +282,7 @@ async fn modify_multiple_owners() { #[tokio::test(flavor = "multi_thread")] async fn check_ownership_two_crates() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let team = new_team("team_foo") @@ -322,7 +322,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let team = new_team("github:test_org:team_sloth") @@ -356,7 +356,7 @@ async fn check_ownership_one_crate() { #[tokio::test(flavor = "multi_thread")] async fn add_existing_team() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let t = new_team("github:test_org:bananas") @@ -383,16 +383,13 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let krate = CrateBuilder::new("foo_my_packages", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; - krate - .owner_remove(&mut async_conn, &user.gh_login) - .await - .unwrap(); + krate.owner_remove(&mut conn, &user.gh_login).await.unwrap(); let json: UserResponse = anon .get("/api/v1/crates/foo_my_packages/owner_user") @@ -440,7 +437,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let krate = CrateBuilder::new("invited_crate", owner.id) @@ -479,7 +476,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let user = app.db_new_user("invited_user").await; @@ -530,7 +527,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let invited_user = app.db_new_user("user_bar").await; @@ -565,7 +562,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let invited_user = app.db_new_user("user_bar").await; @@ -596,7 +593,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let invited_user = app.db_new_user("user_bar").await; @@ -632,7 +629,7 @@ async fn test_accept_invitation_by_mail() { pub async fn expire_invitation(app: &TestApp, crate_id: i32) { use crate::schema::crate_owner_invitations; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let expiration = app.as_inner().config.ownership_invitations_expiration_days as i64; let created_at = (Utc::now() - Duration::days(expiration)).naive_utc(); @@ -648,7 +645,7 @@ pub async fn expire_invitation(app: &TestApp, crate_id: i32) { #[tokio::test(flavor = "multi_thread")] async fn test_accept_expired_invitation() { let (app, anon, owner, owner_token) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let invited_user = app.db_new_user("demo_user").await; @@ -690,7 +687,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let invited_user = app.db_new_user("demo_user").await; @@ -720,7 +717,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); let _invited_user = app.db_new_user("demo_user").await; @@ -767,7 +764,7 @@ async fn inactive_users_dont_get_invitations() { use crate::models::NewUser; let (app, _, owner, owner_token) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); // An inactive user with gh_id -1 and an active user with a non-negative gh_id both exist @@ -806,7 +803,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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let owner = owner.as_model(); // An inactive user with a lower gh_id and an active user with a higher gh_id both exist diff --git a/src/tests/pagination.rs b/src/tests/pagination.rs index 3ff704dae0e..542c38b9c15 100644 --- a/src/tests/pagination.rs +++ b/src/tests/pagination.rs @@ -14,7 +14,7 @@ async fn pagination_blocks_ip_from_cidr_block_list() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("pagination_links_1", user.id) diff --git a/src/tests/read_only_mode.rs b/src/tests/read_only_mode.rs index c90ec04014c..0a11fc693df 100644 --- a/src/tests/read_only_mode.rs +++ b/src/tests/read_only_mode.rs @@ -28,7 +28,7 @@ async fn cannot_hit_endpoint_which_writes_db_in_read_only_mode() { .with_token() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_yank_read_only", user.as_model().id) .version("1.0.0") @@ -51,11 +51,11 @@ async fn can_download_crate_in_read_only_mode() { .with_user() .await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_download_read_only", user.as_model().id) .version("1.0.0") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = anon @@ -70,7 +70,7 @@ async fn can_download_crate_in_read_only_mode() { let dl_count: Result, _> = version_downloads::table .select(sum(version_downloads::downloads)) - .get_result(&mut async_conn) + .get_result(&mut conn) .await; assert_ok_eq!(dl_count, None); } diff --git a/src/tests/routes/categories/get.rs b/src/tests/routes/categories/get.rs index 9529a07e8ee..5edb1a59541 100644 --- a/src/tests/routes/categories/get.rs +++ b/src/tests/routes/categories/get.rs @@ -11,7 +11,7 @@ use serde_json::Value; #[tokio::test(flavor = "multi_thread")] async fn show() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let url = "/api/v1/categories/foo-bar"; @@ -48,7 +48,7 @@ async fn update_crate() { } let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let cats = vec![ @@ -59,61 +59,60 @@ async fn update_crate() { assert_ok!( insert_into(categories::table) .values(cats) - .execute(&mut async_conn) + .execute(&mut conn) .await ); let krate = CrateBuilder::new("foo_crate", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // Updating with no categories has no effect - Category::update_crate(&mut async_conn, krate.id, &[]) + Category::update_crate(&mut conn, krate.id, &[]) .await .unwrap(); assert_eq!(count(&anon, "cat1").await, 0); assert_eq!(count(&anon, "category-2").await, 0); // Happy path adding one category - Category::update_crate(&mut async_conn, krate.id, &["cat1"]) + Category::update_crate(&mut conn, krate.id, &["cat1"]) .await .unwrap(); assert_eq!(count(&anon, "cat1").await, 1); assert_eq!(count(&anon, "category-2").await, 0); // Replacing one category with another - Category::update_crate(&mut async_conn, krate.id, &["category-2"]) + Category::update_crate(&mut conn, krate.id, &["category-2"]) .await .unwrap(); assert_eq!(count(&anon, "cat1").await, 0); assert_eq!(count(&anon, "category-2").await, 1); // Removing one category - Category::update_crate(&mut async_conn, krate.id, &[]) + Category::update_crate(&mut conn, krate.id, &[]) .await .unwrap(); assert_eq!(count(&anon, "cat1").await, 0); assert_eq!(count(&anon, "category-2").await, 0); // Adding 2 categories - Category::update_crate(&mut async_conn, krate.id, &["cat1", "category-2"]) + Category::update_crate(&mut conn, krate.id, &["cat1", "category-2"]) .await .unwrap(); assert_eq!(count(&anon, "cat1").await, 1); assert_eq!(count(&anon, "category-2").await, 1); // Removing all categories - Category::update_crate(&mut async_conn, krate.id, &[]) + Category::update_crate(&mut conn, krate.id, &[]) .await .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 - let invalid_categories = - Category::update_crate(&mut async_conn, krate.id, &["cat1", "catnope"]) - .await - .unwrap(); + let invalid_categories = Category::update_crate(&mut conn, krate.id, &["cat1", "catnope"]) + .await + .unwrap(); assert_eq!(invalid_categories, vec!["catnope"]); assert_eq!(count(&anon, "cat1").await, 1); assert_eq!(count(&anon, "category-2").await, 0); @@ -125,7 +124,7 @@ async fn update_crate() { assert_eq!(json.meta.total, 2); // Attempting to add a category by display text; must use slug - Category::update_crate(&mut async_conn, krate.id, &["Category 2"]) + Category::update_crate(&mut conn, krate.id, &["Category 2"]) .await .unwrap(); assert_eq!(count(&anon, "cat1").await, 0); @@ -135,11 +134,11 @@ async fn update_crate() { assert_ok!( insert_into(categories::table) .values(new_category("cat1::bar", "cat1::bar", "bar crates")) - .execute(&mut async_conn) + .execute(&mut conn) .await ); - Category::update_crate(&mut async_conn, krate.id, &["cat1", "cat1::bar"]) + Category::update_crate(&mut conn, krate.id, &["cat1", "cat1::bar"]) .await .unwrap(); diff --git a/src/tests/routes/categories/list.rs b/src/tests/routes/categories/list.rs index 3d99f5bbb31..4e344344c81 100644 --- a/src/tests/routes/categories/list.rs +++ b/src/tests/routes/categories/list.rs @@ -9,7 +9,7 @@ use serde_json::Value; #[tokio::test(flavor = "multi_thread")] async fn index() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // List 0 categories if none exist 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 e66a9d6be1e..d9104d705cd 100644 --- a/src/tests/routes/category_slugs/list.rs +++ b/src/tests/routes/category_slugs/list.rs @@ -9,7 +9,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let cats = vec![ new_category("Foo", "foo", "For crates that foo"), diff --git a/src/tests/routes/crates/downloads.rs b/src/tests/routes/crates/downloads.rs index 3fcd4a84c64..057f551c675 100644 --- a/src/tests/routes/crates/downloads.rs +++ b/src/tests/routes/crates/downloads.rs @@ -67,12 +67,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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_download", user.id) .version(VersionBuilder::new("1.0.0")) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // TODO: test the with_json code path @@ -82,7 +82,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; - save_version_downloads("foo_download", "1.0.0", 1, &mut async_conn).await; + save_version_downloads("foo_download", "1.0.0", 1, &mut conn).await; // Now that the counters are persisted the download counts show up. assert_dl_count(&anon, "foo_download/1.0.0", None, 1).await; @@ -103,7 +103,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", user.as_model().id) .version(VersionBuilder::new("1.0.0")) @@ -119,13 +119,13 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_id = cookie.as_model().id; CrateBuilder::new("foo", user_id) .version("1.0.0") .version("1.1.0") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; download(&anon, "foo/1.0.0").await; @@ -133,8 +133,8 @@ async fn test_crate_downloads() { download(&anon, "foo/1.0.0").await; download(&anon, "foo/1.1.0").await; - save_version_downloads("foo", "1.0.0", 3, &mut async_conn).await; - save_version_downloads("foo", "1.1.0", 1, &mut async_conn).await; + save_version_downloads("foo", "1.0.0", 3, &mut conn).await; + save_version_downloads("foo", "1.1.0", 1, &mut conn).await; let response = anon.get::<()>("/api/v1/crates/foo/downloads").await; assert_eq!(response.status(), StatusCode::OK); @@ -160,13 +160,13 @@ async fn test_crate_downloads() { #[tokio::test(flavor = "multi_thread")] async fn test_version_downloads() { let (app, anon, cookie) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_id = cookie.as_model().id; CrateBuilder::new("foo", user_id) .version("1.0.0") .version("1.1.0") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; download(&anon, "foo/1.0.0").await; @@ -174,8 +174,8 @@ async fn test_version_downloads() { download(&anon, "foo/1.0.0").await; download(&anon, "foo/1.1.0").await; - save_version_downloads("foo", "1.0.0", 3, &mut async_conn).await; - save_version_downloads("foo", "1.1.0", 1, &mut async_conn).await; + save_version_downloads("foo", "1.0.0", 3, &mut conn).await; + save_version_downloads("foo", "1.1.0", 1, &mut conn).await; 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 fe7def9efaa..648f417c558 100644 --- a/src/tests/routes/crates/following.rs +++ b/src/tests/routes/crates/following.rs @@ -13,7 +13,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let api_token = token.as_model(); let a_crate = "a_crate"; diff --git a/src/tests/routes/crates/list.rs b/src/tests/routes/crates/list.rs index a3248e058b2..1b9801c9537 100644 --- a/src/tests/routes/crates/list.rs +++ b/src/tests/routes/crates/list.rs @@ -15,7 +15,7 @@ use std::sync::LazyLock; #[tokio::test(flavor = "multi_thread")] async fn index() { let (app, anon) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; for json in search_both(&anon, "").await { assert_eq!(json.crates.len(), 0); @@ -25,12 +25,12 @@ async fn index() { let user_id = insert_into(users::table) .values(new_user("foo")) .returning(users::id) - .get_result(&mut async_conn) + .get_result(&mut conn) .await .unwrap(); let krate = CrateBuilder::new("fooindex", user_id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; for json in search_both(&anon, "").await { @@ -45,30 +45,30 @@ async fn index() { #[allow(clippy::cognitive_complexity)] async fn index_queries() { let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let krate = CrateBuilder::new("foo_index_queries", user.id) .readme("readme") .description("description") .keyword("kw1") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let krate2 = CrateBuilder::new("BAR_INDEX_QUERIES", user.id) .keyword("KW1") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; CrateBuilder::new("foo", user.id) .keyword("kw3") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; CrateBuilder::new("two-keywords", user.id) .keyword("kw1") .keyword("kw3") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; for json in search_both(&anon, "q=baz").await { @@ -170,14 +170,14 @@ async fn index_queries() { insert_into(categories::table) .values(cats) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); - Category::update_crate(&mut async_conn, krate.id, &["cat1"]) + Category::update_crate(&mut conn, krate.id, &["cat1"]) .await .unwrap(); - Category::update_crate(&mut async_conn, krate2.id, &["cat1::bar"]) + Category::update_crate(&mut conn, krate2.id, &["cat1::bar"]) .await .unwrap(); @@ -215,7 +215,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("which", user.id) @@ -235,7 +235,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_exact", user.id) @@ -284,7 +284,7 @@ async fn exact_match_first_on_queries() { #[allow(clippy::cognitive_complexity)] async fn index_sorting() { let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); // To test that the unique ordering of seed-based pagination is correct, we need to @@ -294,60 +294,60 @@ async fn index_sorting() { .description("bar_sort baz_sort const") .downloads(50) .recent_downloads(50) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; 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 async_conn) + .expect_build(&mut conn) .await; 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 async_conn) + .expect_build(&mut conn) .await; let krate4 = CrateBuilder::new("other_sort", user.id) .description("other_sort const") .downloads(100_000) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // Set the created at column for each crate update(&krate1) .set(crates::created_at.eq(now - 4.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate2) .set(crates::created_at.eq(now - 1.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(crates::table.filter(crates::id.eq_any(vec![krate3.id, krate4.id]))) .set(crates::created_at.eq(now - 3.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); // Set the updated at column for each crate update(&krate1) .set(crates::updated_at.eq(now - 3.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(crates::table.filter(crates::id.eq_any(vec![krate2.id, krate3.id]))) .set(crates::updated_at.eq(now - 5.days())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate4) .set(crates::updated_at.eq(now)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -514,77 +514,77 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let krate1 = CrateBuilder::new("foo_sort", user.id) .description("bar_sort baz_sort const") .downloads(50) .recent_downloads(50) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; 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 async_conn) + .expect_build(&mut conn) .await; 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 async_conn) + .expect_build(&mut conn) .await; let krate4 = CrateBuilder::new("other_sort", user.id) .description("other_sort const") .downloads(999_999) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // Set the created at column for each crate update(&krate1) .set(crates::created_at.eq(now - 4.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate2) .set(crates::created_at.eq(now - 1.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate3) .set(crates::created_at.eq(now - 2.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate4) .set(crates::created_at.eq(now - 3.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); // Set the updated at column for each crate update(&krate1) .set(crates::updated_at.eq(now - 3.weeks())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate2) .set(crates::updated_at.eq(now - 5.days())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate3) .set(crates::updated_at.eq(now - 10.seconds())) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); update(&krate4) .set(crates::updated_at.eq(now)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -656,7 +656,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo", user.id) @@ -688,7 +688,7 @@ async fn multiple_ids() { #[tokio::test(flavor = "multi_thread")] async fn loose_search_order() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); // exact match should be first @@ -739,7 +739,7 @@ async fn loose_search_order() { #[tokio::test(flavor = "multi_thread")] async fn index_include_yanked() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("unyanked", user.id) @@ -807,7 +807,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_yanked_version", user.id) @@ -828,7 +828,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo", user.id) @@ -858,7 +858,7 @@ async fn max_stable_version() { #[tokio::test(flavor = "multi_thread")] async fn test_recent_download_count() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); // More than 90 days ago @@ -896,7 +896,7 @@ async fn test_recent_download_count() { #[tokio::test(flavor = "multi_thread")] async fn test_zero_downloads() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); // More than 90 days ago @@ -921,7 +921,7 @@ async fn test_zero_downloads() { #[tokio::test(flavor = "multi_thread")] async fn test_default_sort_recent() { let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); // More than 90 days ago @@ -930,7 +930,7 @@ async fn test_default_sort_recent() { .keyword("dog") .downloads(10) .recent_downloads(10) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let potato_crate = CrateBuilder::new("sweet_potato_snack", user.id) @@ -938,7 +938,7 @@ async fn test_default_sort_recent() { .keyword("dog") .downloads(20) .recent_downloads(0) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // test that index for keywords is sorted by recent_downloads @@ -958,14 +958,14 @@ async fn test_default_sort_recent() { insert_into(categories::table) .values(new_category("Animal", "animal", "animal crates")) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); - Category::update_crate(&mut async_conn, green_crate.id, &["animal"]) + Category::update_crate(&mut conn, green_crate.id, &["animal"]) .await .unwrap(); - Category::update_crate(&mut async_conn, potato_crate.id, &["animal"]) + Category::update_crate(&mut conn, potato_crate.id, &["animal"]) .await .unwrap(); @@ -988,7 +988,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("pagination_links_1", user.id) @@ -1039,7 +1039,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("pagination_links_1", user.id) @@ -1094,7 +1094,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("pagination_links_1", user.id) @@ -1143,7 +1143,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("pagination_links_1", user.id) @@ -1172,7 +1172,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let id = user.as_model().id; CrateBuilder::new("foo_my_packages", id) @@ -1188,13 +1188,13 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let krate = CrateBuilder::new("foo_my_packages", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; - krate.owner_remove(&mut async_conn, "foo").await.unwrap(); + krate.owner_remove(&mut conn, "foo").await.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 131d5ddeb99..9383f46b626 100644 --- a/src/tests/routes/crates/owners/add.rs +++ b/src/tests/routes/crates/owners/add.rs @@ -11,7 +11,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_cargo_invite_owners() { let (app, _, owner) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let new_user = app.db_new_user("cilantro").await; CrateBuilder::new("guacamole", owner.as_model().id) @@ -38,7 +38,7 @@ async fn test_cargo_invite_owners() { #[tokio::test(flavor = "multi_thread")] async fn owner_change_via_cookie() { let (app, _, cookie) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -55,7 +55,7 @@ async fn owner_change_via_cookie() { #[tokio::test(flavor = "multi_thread")] async fn owner_change_via_token() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -75,7 +75,7 @@ async fn owner_change_via_change_owner_token() { .with_scoped_token(None, Some(vec![EndpointScope::ChangeOwners])) .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -96,7 +96,7 @@ async fn owner_change_via_change_owner_token_with_matching_crate_scope() { let (app, _, _, token) = TestApp::full() .with_scoped_token(crate_scopes, endpoint_scopes) .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -117,7 +117,7 @@ async fn owner_change_via_change_owner_token_with_wrong_crate_scope() { let (app, _, _, token) = TestApp::full() .with_scoped_token(crate_scopes, endpoint_scopes) .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -137,7 +137,7 @@ async fn owner_change_via_publish_token() { .with_scoped_token(None, Some(vec![EndpointScope::PublishUpdate])) .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -154,7 +154,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("user-2").await; let user2 = user2.as_model(); @@ -171,7 +171,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", user1.as_model().id) .expect_build(&mut conn) @@ -189,7 +189,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; app.db_new_user("bar").await; CrateBuilder::new("foo", user.as_model().id) @@ -224,7 +224,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; app.db_new_user("invited_user").await; CrateBuilder::new("crate_name", owner.as_model().user_id) @@ -254,7 +254,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; app.db_new_user("invited_user").await; let krate = CrateBuilder::new("crate_name", owner.as_model().user_id) @@ -297,7 +297,7 @@ async fn test_unknown_crate() { #[tokio::test(flavor = "multi_thread")] async fn test_unknown_user() { let (app, _, cookie) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", cookie.as_model().id) .expect_build(&mut conn) @@ -311,7 +311,7 @@ async fn test_unknown_user() { #[tokio::test(flavor = "multi_thread")] async fn test_unknown_team() { let (app, _, cookie) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", cookie.as_model().id) .expect_build(&mut conn) @@ -327,7 +327,7 @@ async fn test_unknown_team() { #[tokio::test(flavor = "multi_thread")] async fn max_invites_per_request() { let (app, _, _, owner) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("crate_name", owner.as_model().user_id) .expect_build(&mut conn) @@ -351,7 +351,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("crate_name", token.as_model().user_id) .expect_build(&mut conn) diff --git a/src/tests/routes/crates/owners/remove.rs b/src/tests/routes/crates/owners/remove.rs index 051287a0c75..f226ec457c4 100644 --- a/src/tests/routes/crates/owners/remove.rs +++ b/src/tests/routes/crates/owners/remove.rs @@ -9,7 +9,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_owner_change_with_invalid_json() { let (app, _, user) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; app.db_new_user("bar").await; CrateBuilder::new("foo", user.as_model().id) @@ -54,7 +54,7 @@ async fn test_unknown_crate() { #[tokio::test(flavor = "multi_thread")] async fn test_unknown_user() { let (app, _, cookie) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", cookie.as_model().id) .expect_build(&mut conn) @@ -68,7 +68,7 @@ async fn test_unknown_user() { #[tokio::test(flavor = "multi_thread")] async fn test_unknown_team() { let (app, _, cookie) = TestApp::full().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", cookie.as_model().id) .expect_build(&mut conn) @@ -87,10 +87,10 @@ async fn test_remove_uppercase_user() { let (app, _, cookie) = TestApp::full().with_user().await; let user2 = app.db_new_user("user2").await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let krate = CrateBuilder::new("foo", cookie.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; diesel::insert_into(crate_owners::table) @@ -101,7 +101,7 @@ async fn test_remove_uppercase_user() { owner_kind: OwnerKind::User, email_notifications: true, }) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -150,7 +150,7 @@ async fn test_remove_uppercase_team() { }); let (app, _, cookie) = TestApp::full().with_github(github_mock).with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("crate42", cookie.as_model().id) .expect_build(&mut conn) diff --git a/src/tests/routes/crates/read.rs b/src/tests/routes/crates/read.rs index b13a3a121e6..7825c3b638d 100644 --- a/src/tests/routes/crates/read.rs +++ b/src/tests/routes/crates/read.rs @@ -7,7 +7,7 @@ use insta::{assert_json_snapshot, assert_snapshot}; #[tokio::test(flavor = "multi_thread")] async fn show() { let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); use crate::schema::versions; @@ -23,7 +23,7 @@ async fn show() { .keyword("kw1") .downloads(20) .recent_downloads(10) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // Make version 1.0.0 mimic a version published before we started recording who published @@ -32,7 +32,7 @@ async fn show() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -50,7 +50,7 @@ async fn show() { #[tokio::test(flavor = "multi_thread")] async fn show_minimal() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_show_minimal", user.id) @@ -79,7 +79,7 @@ async fn show_minimal() { #[tokio::test(flavor = "multi_thread")] async fn show_all_yanked() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_show", user.id) @@ -150,7 +150,7 @@ async fn version_size() { #[tokio::test(flavor = "multi_thread")] async fn block_bad_documentation_url() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_bad_doc_url", user.id) @@ -165,7 +165,7 @@ async fn block_bad_documentation_url() { #[tokio::test(flavor = "multi_thread")] async fn test_new_name() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("new", user.as_model().id) .expect_build(&mut conn) diff --git a/src/tests/routes/crates/reverse_dependencies.rs b/src/tests/routes/crates/reverse_dependencies.rs index a645cd646cb..a9c4b426899 100644 --- a/src/tests/routes/crates/reverse_dependencies.rs +++ b/src/tests/routes/crates/reverse_dependencies.rs @@ -6,7 +6,7 @@ use insta::{assert_json_snapshot, assert_snapshot}; #[tokio::test(flavor = "multi_thread")] async fn reverse_dependencies() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c1 = CrateBuilder::new("c1", user.id) @@ -46,7 +46,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c1 = CrateBuilder::new("c1", user.id) @@ -73,7 +73,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c1 = CrateBuilder::new("c1", user.id) @@ -100,7 +100,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c1 = CrateBuilder::new("c1", user.id) @@ -132,18 +132,18 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c1 = CrateBuilder::new("c1", user.id) .version("1.0.0") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; CrateBuilder::new("c2", user.id) .version("1.0.0") .version(VersionBuilder::new("2.0.0").dependency(&c1, None)) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = anon @@ -161,7 +161,7 @@ async fn yanked_versions_not_included_in_reverse_dependencies() { diesel::update(versions::table.filter(versions::num.eq("2.0.0"))) .set(versions::yanked.eq(true)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -178,7 +178,7 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); use crate::schema::versions; @@ -187,11 +187,11 @@ async fn reverse_dependencies_includes_published_by_user_when_present() { let c1 = CrateBuilder::new("c1", user.id) .version("1.0.0") - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; CrateBuilder::new("c2", user.id) .version(VersionBuilder::new("2.0.0").dependency(&c1, None)) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // Make c2's version (and,incidentally, c1's, but that doesn't matter) mimic a version @@ -199,14 +199,14 @@ async fn reverse_dependencies_includes_published_by_user_when_present() { let none: Option = None; update(versions::table) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .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 async_conn) + .expect_build(&mut conn) .await; let response = anon @@ -222,7 +222,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let large_but_valid_version_number = format!("1.0.{}", u64::MAX); diff --git a/src/tests/routes/crates/versions/authors.rs b/src/tests/routes/crates/versions/authors.rs index 5435430dcf7..8796fb7b328 100644 --- a/src/tests/routes/crates/versions/authors.rs +++ b/src/tests/routes/crates/versions/authors.rs @@ -6,7 +6,7 @@ use serde_json::Value; #[tokio::test(flavor = "multi_thread")] async fn authors() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_authors", user.id) diff --git a/src/tests/routes/crates/versions/dependencies.rs b/src/tests/routes/crates/versions/dependencies.rs index 9a3b3e485b4..ecd6707afc7 100644 --- a/src/tests/routes/crates/versions/dependencies.rs +++ b/src/tests/routes/crates/versions/dependencies.rs @@ -12,7 +12,7 @@ pub struct Deps { #[tokio::test(flavor = "multi_thread")] async fn dependencies() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c1 = CrateBuilder::new("foo_deps", user.id) diff --git a/src/tests/routes/crates/versions/download.rs b/src/tests/routes/crates/versions/download.rs index 5b8ec89a6c1..26fa1214991 100644 --- a/src/tests/routes/crates/versions/download.rs +++ b/src/tests/routes/crates/versions/download.rs @@ -4,7 +4,7 @@ use crate::tests::util::{RequestHelper, TestApp}; #[tokio::test(flavor = "multi_thread")] async fn test_redirects() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo-download", user.as_model().id) .version(VersionBuilder::new("1.0.0")) @@ -35,7 +35,7 @@ async fn test_redirects() { #[tokio::test(flavor = "multi_thread")] async fn download_with_build_metadata() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo", user.id) diff --git a/src/tests/routes/crates/versions/list.rs b/src/tests/routes/crates/versions/list.rs index 7ef928efac5..cd073547379 100644 --- a/src/tests/routes/crates/versions/list.rs +++ b/src/tests/routes/crates/versions/list.rs @@ -12,14 +12,14 @@ use serde_json::json; #[tokio::test(flavor = "multi_thread")] async fn versions() { let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); 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 async_conn) + .expect_build(&mut conn) .await; // Make version 1.0.0 mimic a version published before we started recording who published @@ -28,7 +28,7 @@ async fn versions() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -52,7 +52,7 @@ async fn test_unknown_crate() { #[tokio::test(flavor = "multi_thread")] async fn test_sorting() { let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let versions = [ @@ -71,7 +71,7 @@ async fn test_sorting() { for version in versions { builder = builder.version(version); } - builder.expect_build(&mut async_conn).await; + builder.expect_build(&mut conn).await; // 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); @@ -84,14 +84,14 @@ async fn test_sorting() { 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 async_conn) + .execute(&mut conn) .await .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 async_conn) + .expect_build(&mut conn) .await; let expects = [ @@ -156,14 +156,14 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); 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 async_conn) + .expect_build(&mut conn) .await; // Make version 1.0.0 mimic a version published before we started recording who published @@ -172,7 +172,7 @@ async fn test_seek_based_pagination_semver_sorting() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -241,14 +241,14 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); 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 async_conn) + .expect_build(&mut conn) .await; // Make version 1.0.0 mimic a version published before we started recording who published @@ -257,7 +257,7 @@ async fn test_seek_based_pagination_date_sorting() { update(versions::table) .filter(versions::num.eq("1.0.0")) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); @@ -329,7 +329,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("foo_versions", user.id) diff --git a/src/tests/routes/crates/versions/read.rs b/src/tests/routes/crates/versions/read.rs index c6a74dcbfc3..3ae608fa16a 100644 --- a/src/tests/routes/crates/versions/read.rs +++ b/src/tests/routes/crates/versions/read.rs @@ -8,7 +8,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let krate = CrateBuilder::new("foo_vers_show", user.id) @@ -37,21 +37,21 @@ async fn show_by_crate_name_and_semver_no_published_by() { use diesel::update; let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let krate = CrateBuilder::new("foo_vers_show_no_pb", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let version = VersionBuilder::new("1.0.0") - .expect_build(krate.id, user.id, &mut async_conn) + .expect_build(krate.id, user.id, &mut conn) .await; // Mimic a version published before we started recording who published versions let none: Option = None; update(versions::table) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); diff --git a/src/tests/routes/crates/versions/yank_unyank.rs b/src/tests/routes/crates/versions/yank_unyank.rs index e6467d7f499..25474a81ea2 100644 --- a/src/tests/routes/crates/versions/yank_unyank.rs +++ b/src/tests/routes/crates/versions/yank_unyank.rs @@ -63,7 +63,7 @@ impl YankRequestHelper for T { #[tokio::test(flavor = "multi_thread")] async fn yank_by_a_non_owner_fails() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let another_user = app.db_new_user("bar").await; let another_user = another_user.as_model(); @@ -146,7 +146,7 @@ mod auth { } async fn is_yanked(app: &TestApp) -> bool { - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; versions::table .inner_join(crates::table) @@ -381,7 +381,7 @@ mod auth { #[tokio::test(flavor = "multi_thread")] async fn admin() { let (app, _, _) = prepare().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let admin = app.db_new_user("admin").await; diff --git a/src/tests/routes/keywords/list.rs b/src/tests/routes/keywords/list.rs index 82e244deef4..5892c20126d 100644 --- a/src/tests/routes/keywords/list.rs +++ b/src/tests/routes/keywords/list.rs @@ -17,7 +17,7 @@ struct KeywordMeta { async fn index() { let url = "/api/v1/keywords"; let (app, anon) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let json: KeywordList = anon.get(url).await.good(); assert_eq!(json.keywords.len(), 0); diff --git a/src/tests/routes/keywords/read.rs b/src/tests/routes/keywords/read.rs index 3c37b1afa58..f2fe7fb6582 100644 --- a/src/tests/routes/keywords/read.rs +++ b/src/tests/routes/keywords/read.rs @@ -12,7 +12,7 @@ struct GoodKeyword { async fn show() { let url = "/api/v1/keywords/foo"; let (app, anon) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; anon.get(url).await.assert_not_found(); @@ -28,7 +28,7 @@ async fn show() { async fn uppercase() { let url = "/api/v1/keywords/UPPER"; let (app, anon) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; anon.get(url).await.assert_not_found(); @@ -43,7 +43,7 @@ async fn uppercase() { #[tokio::test(flavor = "multi_thread")] async fn update_crate() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); async fn cnt(kw: &str, client: &impl RequestHelper) -> usize { diff --git a/src/tests/routes/me/email_notifications.rs b/src/tests/routes/me/email_notifications.rs index 4fb9effb7ae..387756f03c3 100644 --- a/src/tests/routes/me/email_notifications.rs +++ b/src/tests/routes/me/email_notifications.rs @@ -28,7 +28,7 @@ impl crate::tests::util::MockCookieUser { #[tokio::test(flavor = "multi_thread")] async fn test_update_email_notifications() { let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let a = CrateBuilder::new("test_package", user.as_model().id) .expect_build(&mut conn) @@ -113,17 +113,17 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_id = diesel::insert_into(users::table) .values(new_user("arbitrary_username")) .returning(users::id) - .get_result(&mut async_conn) + .get_result(&mut conn) .await .unwrap(); let not_my_crate = CrateBuilder::new("test_package", user_id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; user.update_email_notifications(vec![EmailNotificationsUpdate { @@ -135,7 +135,7 @@ async fn test_update_email_notifications_not_owned() { let email_notifications: bool = crate_owners::table .select(crate_owners::email_notifications) .filter(crate_owners::crate_id.eq(not_my_crate.id)) - .first(&mut async_conn) + .first(&mut conn) .await .unwrap(); diff --git a/src/tests/routes/me/get.rs b/src/tests/routes/me/get.rs index 5283ef412c8..4877ea4e840 100644 --- a/src/tests/routes/me/get.rs +++ b/src/tests/routes/me/get.rs @@ -20,7 +20,7 @@ pub struct UserShowPrivateResponse { #[tokio::test(flavor = "multi_thread")] async fn me() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let response = anon.get::<()>("/api/v1/me").await; assert_eq!(response.status(), StatusCode::FORBIDDEN); @@ -42,14 +42,14 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_model = user.as_model(); let krate = CrateBuilder::new("foo_my_packages", user_model.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; krate - .owner_remove(&mut async_conn, &user_model.gh_login) + .owner_remove(&mut conn, &user_model.gh_login) .await .unwrap(); diff --git a/src/tests/routes/me/tokens/create.rs b/src/tests/routes/me/tokens/create.rs index d14fd6a9eb7..529295631f4 100644 --- a/src/tests/routes/me/tokens/create.rs +++ b/src/tests/routes/me/tokens/create.rs @@ -42,7 +42,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let id = user.as_model().id; for i in 0..1000 { @@ -58,7 +58,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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let response = user.put::<()>("/api/v1/me/tokens", NEW_BAR).await; assert_eq!(response.status(), StatusCode::OK); @@ -124,7 +124,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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let json = json!({ "api_token": { @@ -174,7 +174,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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let json = json!({ "api_token": { diff --git a/src/tests/routes/me/tokens/delete.rs b/src/tests/routes/me/tokens/delete.rs index 503567ac3f8..44b72cd321b 100644 --- a/src/tests/routes/me/tokens/delete.rs +++ b/src/tests/routes/me/tokens/delete.rs @@ -16,7 +16,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user1 = user1.as_model(); let token = token.as_model(); let user2 = app.db_new_user("baz").await; @@ -51,7 +51,7 @@ async fn revoke_token_doesnt_revoke_other_users_token() { #[tokio::test(flavor = "multi_thread")] async fn revoke_token_success() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // List tokens contains the token let tokens: Vec = assert_ok!( diff --git a/src/tests/routes/me/tokens/delete_current.rs b/src/tests/routes/me/tokens/delete_current.rs index 1a13c5a167d..755ef0b0803 100644 --- a/src/tests/routes/me/tokens/delete_current.rs +++ b/src/tests/routes/me/tokens/delete_current.rs @@ -9,7 +9,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn revoke_current_token_success() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Ensure that the token currently exists in the database @@ -51,7 +51,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // Ensure that the token currently exists in the database diff --git a/src/tests/routes/me/tokens/get.rs b/src/tests/routes/me/tokens/get.rs index b015ce40364..56d06be1466 100644 --- a/src/tests/routes/me/tokens/get.rs +++ b/src/tests/routes/me/tokens/get.rs @@ -27,7 +27,7 @@ async fn show() { #[tokio::test(flavor = "multi_thread")] async fn show_token_with_scopes() { let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_model = user.as_model(); let id = user_model.id; @@ -66,7 +66,7 @@ async fn show_with_anonymous_user() { #[tokio::test(flavor = "multi_thread")] async fn show_other_user_token() { let (app, _, user1) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user2 = app.db_new_user("baz").await; let user2 = user2.as_model(); diff --git a/src/tests/routes/me/tokens/list.rs b/src/tests/routes/me/tokens/list.rs index e1f3ae64f40..ec1eb6574c0 100644 --- a/src/tests/routes/me/tokens/list.rs +++ b/src/tests/routes/me/tokens/list.rs @@ -30,7 +30,7 @@ async fn list_empty() { #[tokio::test(flavor = "multi_thread")] async fn list_tokens() { let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let id = user.as_model().id; assert_ok!(ApiToken::insert(&mut conn, id, "bar").await); @@ -77,7 +77,7 @@ async fn list_recently_expired_tokens() { } let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let id = user.as_model().id; assert_ok!(ApiToken::insert(&mut conn, id, "bar").await); @@ -128,7 +128,7 @@ async fn list_recently_expired_tokens() { #[tokio::test(flavor = "multi_thread")] async fn list_tokens_exclude_revoked() { let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let id = user.as_model().id; let token1 = assert_ok!(ApiToken::insert(&mut conn, id, "bar").await); diff --git a/src/tests/routes/me/updates.rs b/src/tests/routes/me/updates.rs index 6f67ea99a84..53ba84f7d44 100644 --- a/src/tests/routes/me/updates.rs +++ b/src/tests/routes/me/updates.rs @@ -29,13 +29,13 @@ async fn following() { } let (app, _, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_model = user.as_model(); let user_id = user_model.id; CrateBuilder::new("foo_fighters", user_id) .version(VersionBuilder::new("1.0.0")) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // Make foo_fighters's version mimic a version published before we started recording who @@ -43,13 +43,13 @@ async fn following() { let none: Option = None; update(versions::table) .set(versions::published_by.eq(none)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); CrateBuilder::new("bar_fighters", user_id) .version(VersionBuilder::new("1.0.0")) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let r: R = user.get("/api/v1/me/updates").await.good(); diff --git a/src/tests/routes/private/crate_owner_invitations.rs b/src/tests/routes/private/crate_owner_invitations.rs index 260f438eb72..d34cfd8e4fd 100644 --- a/src/tests/routes/private/crate_owner_invitations.rs +++ b/src/tests/routes/private/crate_owner_invitations.rs @@ -29,7 +29,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let crate1 = CrateBuilder::new("crate_1", owner.as_model().id) .expect_build(&mut conn) @@ -170,7 +170,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("invited_user").await; let crate1 = CrateBuilder::new("crate_1", owner.as_model().id) @@ -218,7 +218,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("invited_user").await; let crate1 = CrateBuilder::new("crate_1", owner.as_model().id) @@ -338,7 +338,7 @@ async fn invitation_list_other_users() { #[tokio::test(flavor = "multi_thread")] async fn invitation_list_other_crates() { let (app, _, owner, _) = TestApp::init().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let other_user = app.db_new_user("other").await; CrateBuilder::new("crate_1", owner.as_model().id) diff --git a/src/tests/routes/summary.rs b/src/tests/routes/summary.rs index 32157ad296d..3a21f2d5c7c 100644 --- a/src/tests/routes/summary.rs +++ b/src/tests/routes/summary.rs @@ -30,7 +30,7 @@ async fn summary_doesnt_die() { #[tokio::test(flavor = "multi_thread")] async fn summary_new_crates() { let (app, anon, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); conn.transaction(|conn| { @@ -163,7 +163,7 @@ async fn excluded_crate_id() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("some_downloads", user.id) @@ -221,7 +221,7 @@ async fn all_yanked() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); CrateBuilder::new("some_downloads", user.id) diff --git a/src/tests/routes/users/read.rs b/src/tests/routes/users/read.rs index c8f2d75daec..b77be12ec33 100644 --- a/src/tests/routes/users/read.rs +++ b/src/tests/routes/users/read.rs @@ -25,7 +25,7 @@ async fn show() { #[tokio::test(flavor = "multi_thread")] async fn show_latest_user_case_insensitively() { let (app, anon) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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 diff --git a/src/tests/routes/users/stats.rs b/src/tests/routes/users/stats.rs index 5128785daed..c6fb586607e 100644 --- a/src/tests/routes/users/stats.rs +++ b/src/tests/routes/users/stats.rs @@ -15,48 +15,48 @@ async fn user_total_downloads() { use diesel_async::RunQueryDsl; let (app, anon, user) = TestApp::init().with_user().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let another_user = app.db_new_user("bar").await; let another_user = another_user.as_model(); let krate = CrateBuilder::new("foo_krate1", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate.id))) .set(crate_downloads::downloads.eq(10)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); let krate2 = CrateBuilder::new("foo_krate2", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(krate2.id))) .set(crate_downloads::downloads.eq(20)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); let another_krate = CrateBuilder::new("bar_krate1", another_user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(another_krate.id))) .set(crate_downloads::downloads.eq(2)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); let no_longer_my_krate = CrateBuilder::new("nacho", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; update(crate_downloads::table.filter(crate_downloads::crate_id.eq(no_longer_my_krate.id))) .set(crate_downloads::downloads.eq(5)) - .execute(&mut async_conn) + .execute(&mut conn) .await .unwrap(); no_longer_my_krate - .owner_remove(&mut async_conn, &user.gh_login) + .owner_remove(&mut conn, &user.gh_login) .await .unwrap(); diff --git a/src/tests/server.rs b/src/tests/server.rs index 9e2c7f77a5d..e770faf8284 100644 --- a/src/tests/server.rs +++ b/src/tests/server.rs @@ -26,7 +26,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("dl_no_ua", user.as_model().id) .expect_build(&mut conn) @@ -47,7 +47,7 @@ async fn blocked_traffic_doesnt_panic_if_checked_header_is_not_present() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("dl_no_ua", user.as_model().id) .expect_build(&mut conn) @@ -68,7 +68,7 @@ async fn block_traffic_via_arbitrary_header_and_value() { .with_user() .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("dl_no_ua", user.as_model().id) .expect_build(&mut conn) diff --git a/src/tests/team.rs b/src/tests/team.rs index 723f5c1308d..fb820bff1a3 100644 --- a/src/tests/team.rs +++ b/src/tests/team.rs @@ -29,10 +29,10 @@ impl crate::tests::util::MockAnonymousUser { async fn not_github() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_not_github", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = token @@ -45,10 +45,10 @@ async fn not_github() { #[tokio::test(flavor = "multi_thread")] async fn weird_name() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_weird_name", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = token @@ -62,10 +62,10 @@ async fn weird_name() { #[tokio::test(flavor = "multi_thread")] async fn one_colon() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_one_colon", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = token.add_named_owner("foo_one_colon", "github:foo").await; @@ -76,10 +76,10 @@ async fn one_colon() { #[tokio::test(flavor = "multi_thread")] async fn add_nonexistent_team() { let (app, _, user, token) = TestApp::init().with_token().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_add_nonexistent", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = token @@ -93,7 +93,7 @@ async fn add_nonexistent_team() { #[tokio::test(flavor = "multi_thread")] async fn add_renamed_team() { let (app, anon) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("user-all-teams").await; let token = user.db_new_token("arbitrary token name").await; let owner_id = user.as_model().id; @@ -101,7 +101,7 @@ async fn add_renamed_team() { use crate::schema::teams; CrateBuilder::new("foo_renamed_team", owner_id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; // create team with same ID and different name compared to http mock @@ -115,15 +115,12 @@ async fn add_renamed_team() { .github_id(2001) .build(); - new_team - .async_create_or_update(&mut async_conn) - .await - .unwrap(); + new_team.async_create_or_update(&mut conn).await.unwrap(); assert_eq!( teams::table .count() - .get_result::(&mut async_conn) + .get_result::(&mut conn) .await .unwrap(), 1 @@ -143,12 +140,12 @@ async fn add_renamed_team() { #[tokio::test(flavor = "multi_thread")] async fn add_team_mixed_case() { let (app, anon) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("user-all-teams").await; let token = user.db_new_token("arbitrary token name").await; CrateBuilder::new("foo_mixed_case", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token @@ -157,10 +154,10 @@ async fn add_team_mixed_case() { .good(); let krate: Crate = Crate::by_name("foo_mixed_case") - .first(&mut async_conn) + .first(&mut conn) .await .unwrap(); - let owners = krate.async_owners(&mut async_conn).await.unwrap(); + let owners = krate.async_owners(&mut conn).await.unwrap(); assert_eq!(owners.len(), 2); let owner = &owners[1]; assert_eq!(owner.login(), owner.login().to_lowercase()); @@ -173,12 +170,12 @@ async fn add_team_mixed_case() { #[tokio::test(flavor = "multi_thread")] async fn add_team_as_org_owner() { let (app, anon) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("user-org-owner").await; let token = user.db_new_token("arbitrary token name").await; CrateBuilder::new("foo_org_owner", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token @@ -187,10 +184,10 @@ async fn add_team_as_org_owner() { .good(); let krate: Crate = Crate::by_name("foo_org_owner") - .first(&mut async_conn) + .first(&mut conn) .await .unwrap(); - let owners = krate.async_owners(&mut async_conn).await.unwrap(); + let owners = krate.async_owners(&mut conn).await.unwrap(); assert_eq!(owners.len(), 2); let owner = &owners[1]; assert_eq!(owner.login(), owner.login().to_lowercase()); @@ -204,12 +201,12 @@ async fn add_team_as_org_owner() { #[tokio::test(flavor = "multi_thread")] async fn add_team_as_non_member() { let (app, _) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("user-one-team").await; let token = user.db_new_token("arbitrary token name").await; CrateBuilder::new("foo_team_non_member", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; let response = token @@ -222,7 +219,7 @@ async fn add_team_as_non_member() { #[tokio::test(flavor = "multi_thread")] async fn remove_team_as_named_owner() { let (app, _) = TestApp::full().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let username = "user-all-teams"; let user_on_both_teams = app.db_new_user(username).await; let token_on_both_teams = user_on_both_teams @@ -230,7 +227,7 @@ async fn remove_team_as_named_owner() { .await; CrateBuilder::new("foo_remove_team", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -261,14 +258,14 @@ async fn remove_team_as_named_owner() { #[tokio::test(flavor = "multi_thread")] async fn remove_team_as_team_owner() { let (app, _) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_on_both_teams = app.db_new_user("user-all-teams").await; let token_on_both_teams = user_on_both_teams .db_new_token("arbitrary token name") .await; CrateBuilder::new("foo_remove_team_owner", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -297,17 +294,17 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo_remove_nonexistent", user.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; insert_into(teams::table) .values(( teams::login.eq("github:test-org:this-does-not-exist"), teams::github_id.eq(5678), )) - .execute(&mut async_conn) + .execute(&mut conn) .await .expect("couldn't insert nonexistent team"); @@ -325,14 +322,14 @@ async fn remove_nonexistent_team() { #[tokio::test(flavor = "multi_thread")] async fn publish_not_owned() { let (app, _) = TestApp::full().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_on_both_teams = app.db_new_user("user-all-teams").await; let token_on_both_teams = user_on_both_teams .db_new_token("arbitrary token name") .await; CrateBuilder::new("foo_not_owned", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -351,14 +348,14 @@ async fn publish_not_owned() { #[tokio::test(flavor = "multi_thread")] async fn publish_org_owner_owned() { let (app, _) = TestApp::full().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_on_both_teams = app.db_new_user("user-all-teams").await; let token_on_both_teams = user_on_both_teams .db_new_token("arbitrary token name") .await; CrateBuilder::new("foo_not_owned", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -378,14 +375,14 @@ async fn publish_org_owner_owned() { #[tokio::test(flavor = "multi_thread")] async fn publish_owned() { let (app, _) = TestApp::full().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_on_both_teams = app.db_new_user("user-all-teams").await; let token_on_both_teams = user_on_both_teams .db_new_token("arbitrary token name") .await; CrateBuilder::new("foo_team_owned", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -408,14 +405,14 @@ async fn publish_owned() { #[tokio::test(flavor = "multi_thread")] async fn add_owners_as_org_owner() { let (app, _) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_on_both_teams = app.db_new_user("user-all-teams").await; let token_on_both_teams = user_on_both_teams .db_new_token("arbitrary token name") .await; CrateBuilder::new("foo_add_owner", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -436,14 +433,14 @@ async fn add_owners_as_org_owner() { #[tokio::test(flavor = "multi_thread")] async fn add_owners_as_team_owner() { let (app, _) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user_on_both_teams = app.db_new_user("user-all-teams").await; let token_on_both_teams = user_on_both_teams .db_new_token("arbitrary token name") .await; CrateBuilder::new("foo_add_owner", user_on_both_teams.as_model().id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; token_on_both_teams @@ -464,17 +461,17 @@ 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().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let t = new_team("github:test-org:team") - .async_create_or_update(&mut async_conn) + .async_create_or_update(&mut conn) .await .unwrap(); let krate = CrateBuilder::new("foo", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; - add_team_to_crate(&t, &krate, user, &mut async_conn) + add_team_to_crate(&t, &krate, user, &mut conn) .await .unwrap(); @@ -485,7 +482,7 @@ async fn crates_by_team_id() { #[tokio::test(flavor = "multi_thread")] async fn crates_by_team_id_not_including_deleted_owners() { let (app, anon) = TestApp::init().empty().await; - let mut async_conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = app.db_new_user("user-all-teams").await; let user = user.as_model(); @@ -495,18 +492,15 @@ async fn crates_by_team_id_not_including_deleted_owners() { .github_id(2001) .build(); - let t = new_team - .async_create_or_update(&mut async_conn) - .await - .unwrap(); + let t = new_team.async_create_or_update(&mut conn).await.unwrap(); let krate = CrateBuilder::new("foo", user.id) - .expect_build(&mut async_conn) + .expect_build(&mut conn) .await; - add_team_to_crate(&t, &krate, user, &mut async_conn) + add_team_to_crate(&t, &krate, user, &mut conn) .await .unwrap(); - krate.owner_remove(&mut async_conn, &t.login).await.unwrap(); + krate.owner_remove(&mut conn, &t.login).await.unwrap(); 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 38f12ce8e6a..a265f5dd873 100644 --- a/src/tests/token.rs +++ b/src/tests/token.rs @@ -10,7 +10,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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; anon.get(url).await.assert_forbidden(); user.get::(url).await.good(); diff --git a/src/tests/unhealthy_database.rs b/src/tests/unhealthy_database.rs index 28ba0795c01..7136e2ae249 100644 --- a/src/tests/unhealthy_database.rs +++ b/src/tests/unhealthy_database.rs @@ -53,7 +53,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; CrateBuilder::new("foo", token.as_model().user_id) .version("1.0.0") diff --git a/src/tests/user.rs b/src/tests/user.rs index 07a9d16a75e..569cd658cd9 100644 --- a/src/tests/user.rs +++ b/src/tests/user.rs @@ -23,7 +23,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let gh_id = user.as_model().gh_id; let token = token.plaintext(); @@ -55,7 +55,7 @@ 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().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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. @@ -101,7 +101,7 @@ async fn github_with_email_does_not_overwrite_email() { use crate::schema::emails; let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let model = user.as_model(); @@ -162,7 +162,7 @@ async fn test_confirm_user_email() { use crate::schema::emails; let (app, _) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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. @@ -201,7 +201,7 @@ async fn test_existing_user_email() { use diesel::update; let (app, _) = TestApp::init().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; // 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. diff --git a/src/tests/util.rs b/src/tests/util.rs index 842f886dbbc..d7655a912e9 100644 --- a/src/tests/util.rs +++ b/src/tests/util.rs @@ -327,7 +327,7 @@ impl MockCookieUser { endpoint_scopes: Option>, expired_at: Option, ) -> MockTokenUser { - let mut conn = self.app().async_db_conn().await; + let mut conn = self.app().db_conn().await; let token = ApiToken::insert_with_scopes( &mut conn, diff --git a/src/tests/util/test_app.rs b/src/tests/util/test_app.rs index b17ea988e98..feeaf6e7006 100644 --- a/src/tests/util/test_app.rs +++ b/src/tests/util/test_app.rs @@ -111,7 +111,7 @@ impl TestApp { } /// Obtain an async database connection from the primary database pool. - pub async fn async_db_conn(&self) -> AsyncPgConnection { + pub async fn db_conn(&self) -> AsyncPgConnection { self.0.test_database.async_connect().await } @@ -124,7 +124,7 @@ impl TestApp { use diesel::prelude::*; use diesel_async::RunQueryDsl; - let mut conn = self.async_db_conn().await; + let mut conn = self.db_conn().await; let email = format!("{username}@example.com"); diff --git a/src/tests/version.rs b/src/tests/version.rs index ca92335386d..3a2f9556b69 100644 --- a/src/tests/version.rs +++ b/src/tests/version.rs @@ -5,7 +5,7 @@ use crate::tests::TestApp; #[tokio::test(flavor = "multi_thread")] async fn record_rerendered_readme_time() { let (app, _, user) = TestApp::init().with_user().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let user = user.as_model(); let c = CrateBuilder::new("foo_authors", user.id) @@ -15,7 +15,7 @@ async fn record_rerendered_readme_time() { .expect_build(c.id, user.id, &mut conn) .await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; Version::record_readme_rendering(version.id, &mut conn) .await .unwrap(); diff --git a/src/tests/worker/git.rs b/src/tests/worker/git.rs index bb71c032c6d..da00a5c7a48 100644 --- a/src/tests/worker/git.rs +++ b/src/tests/worker/git.rs @@ -10,7 +10,7 @@ use http::StatusCode; #[tokio::test(flavor = "multi_thread")] async fn index_smoke_test() { let (app, _, _, token) = TestApp::full().with_token().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let upstream = app.upstream_index(); // Add a new crate diff --git a/src/tests/worker/rss/sync_crate_feed.rs b/src/tests/worker/rss/sync_crate_feed.rs index 86d124de72a..dc7d7022d43 100644 --- a/src/tests/worker/rss/sync_crate_feed.rs +++ b/src/tests/worker/rss/sync_crate_feed.rs @@ -10,7 +10,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_sync_crate_feed() { let (app, _) = TestApp::full().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; create_version(&mut conn, "foo", "0.1.0", "2024-06-20T10:13:54Z").await; create_version(&mut conn, "foo", "0.1.1", "2024-06-20T12:45:12Z").await; diff --git a/src/tests/worker/rss/sync_crates_feed.rs b/src/tests/worker/rss/sync_crates_feed.rs index b895d87ae7c..a4105b98ee8 100644 --- a/src/tests/worker/rss/sync_crates_feed.rs +++ b/src/tests/worker/rss/sync_crates_feed.rs @@ -10,7 +10,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_sync_crates_feed() { let (app, _) = TestApp::full().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let description = Some("something something foo"); create_crate(&mut conn, "foo", description, "2024-06-20T10:13:54Z").await; diff --git a/src/tests/worker/rss/sync_updates_feed.rs b/src/tests/worker/rss/sync_updates_feed.rs index 2b385e5973e..d76b3012614 100644 --- a/src/tests/worker/rss/sync_updates_feed.rs +++ b/src/tests/worker/rss/sync_updates_feed.rs @@ -10,7 +10,7 @@ use insta::assert_snapshot; #[tokio::test(flavor = "multi_thread")] async fn test_sync_updates_feed() { let (app, _) = TestApp::full().empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; let d = Some("let's try & break this ]]>"); diff --git a/src/tests/worker/sync_admins.rs b/src/tests/worker/sync_admins.rs index 5a29d0494e9..a476f13d702 100644 --- a/src/tests/worker/sync_admins.rs +++ b/src/tests/worker/sync_admins.rs @@ -23,7 +23,7 @@ async fn test_sync_admins_job() { .returning(move |_| Ok(mock_response.clone())); let (app, _) = TestApp::full().with_team_repo(team_repo).empty().await; - let mut conn = app.async_db_conn().await; + let mut conn = app.db_conn().await; create_user("existing-admin", 1, true, &mut conn) .await