From c54f44e61904a423b883ce55766e7a4a92fc82de Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Sat, 16 Nov 2024 19:52:08 +0100 Subject: [PATCH 1/6] rate_limiter: Simplify `new_user()` test helper fn There is no need for an "upsert" operation here since we know that the database is in a clean state in our tests. Additionally, this drops the need for the `Emails` implementation, since all we want is a user in the database, but without any email address confirmation emails being sent out. --- src/rate_limiter.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/rate_limiter.rs b/src/rate_limiter.rs index f8f20ee1dd6..5adb16cda2c 100644 --- a/src/rate_limiter.rs +++ b/src/rate_limiter.rs @@ -181,7 +181,7 @@ struct Bucket { #[cfg(test)] mod tests { use super::*; - use crate::email::Emails; + use crate::schema::users; use crate::test_util::*; #[test] @@ -647,13 +647,17 @@ mod tests { fn new_user(conn: &mut impl Conn, gh_login: &str) -> QueryResult { use crate::models::NewUser; + use diesel::RunQueryDsl; let user = NewUser { gh_login, ..NewUser::default() - } - .create_or_update(None, &Emails::new_in_memory(), conn)?; - Ok(user.id) + }; + + diesel::insert_into(users::table) + .values(user) + .returning(users::id) + .get_result(conn) } fn new_user_bucket( From e8bd2efe1d292d955c5a307c1362c6e2316e52c8 Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Mon, 14 Oct 2024 16:24:32 +0000 Subject: [PATCH 2/6] worker/jobs/downloads/update_metadata: Simplify `user()` test helper fn There is no need for an "upsert" operation here since we know that the database is in a clean state in our tests. Additionally, this drops the need for the `Emails` implementation, since all we want is a user in the database, but without any email address confirmation emails being sent out. --- src/worker/jobs/downloads/update_metadata.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/worker/jobs/downloads/update_metadata.rs b/src/worker/jobs/downloads/update_metadata.rs index 0000c94cf9d..4ba8a910e74 100644 --- a/src/worker/jobs/downloads/update_metadata.rs +++ b/src/worker/jobs/downloads/update_metadata.rs @@ -105,14 +105,15 @@ fn batch_update(batch_size: i64, conn: &mut impl Conn) -> QueryResult { #[cfg(test)] mod tests { use super::*; - use crate::email::Emails; use crate::models::{Crate, NewCrate, NewUser, NewVersion, User, Version}; - use crate::schema::{crate_downloads, crates, versions}; + use crate::schema::{crate_downloads, crates, users, versions}; use crate::test_util::test_db_connection; fn user(conn: &mut impl Conn) -> User { - NewUser::new(2, "login", None, None, "access_token") - .create_or_update(None, &Emails::new_in_memory(), conn) + let user = NewUser::new(2, "login", None, None, "access_token"); + diesel::insert_into(users::table) + .values(user) + .get_result(conn) .unwrap() } From 04b4c29709d32abe774f05e9b1f40dc0170039cf Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Sat, 16 Nov 2024 19:55:29 +0100 Subject: [PATCH 3/6] tests/routes/crates/list: Simplify `new_user()` test helper call There is no need for an "upsert" operation here since we know that the database is in a clean state in our tests. Additionally, this drops the need for the `Emails` implementation, since all we want is a user in the database, but without any email address confirmation emails being sent out. --- src/tests/routes/crates/list.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/tests/routes/crates/list.rs b/src/tests/routes/crates/list.rs index 14495793697..f56a8735ff7 100644 --- a/src/tests/routes/crates/list.rs +++ b/src/tests/routes/crates/list.rs @@ -1,5 +1,5 @@ use crate::models::Category; -use crate::schema::crates; +use crate::schema::{crates, users}; use crate::tests::builders::{CrateBuilder, VersionBuilder}; use crate::tests::util::{RequestHelper, TestApp}; use crate::tests::{new_category, new_user}; @@ -21,11 +21,13 @@ async fn index() { assert_eq!(json.meta.total, 0); } - let u = new_user("foo") - .create_or_update(None, &app.as_inner().emails, &mut conn) + let user_id = insert_into(users::table) + .values(new_user("foo")) + .returning(users::id) + .get_result(&mut conn) .unwrap(); - let krate = CrateBuilder::new("fooindex", u.id).expect_build(&mut conn); + let krate = CrateBuilder::new("fooindex", user_id).expect_build(&mut conn); for json in search_both(&anon, "").await { assert_eq!(json.crates.len(), 1); From d16c4c1f263c901a5f6ad31d155fbe551eece7a0 Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Sat, 16 Nov 2024 19:55:52 +0100 Subject: [PATCH 4/6] tests/owners: Simplify `NewUser` creation There is no need for an "upsert" operation here since we know that the database is in a clean state in our tests. Additionally, this drops the need for the `Emails` implementation, since all we want is a user in the database, but without any email address confirmation emails being sent out. --- src/tests/owners.rs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/tests/owners.rs b/src/tests/owners.rs index 1f1e16446e5..ac720ea4f49 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -12,6 +12,7 @@ use crate::{ }, }; +use crate::schema::users; use chrono::{Duration, Utc}; use diesel::prelude::*; use http::StatusCode; @@ -724,15 +725,18 @@ async fn inactive_users_dont_get_invitations() { let invited_gh_login = "user_bar"; let krate_name = "inactive_test"; - NewUser { + let user = NewUser { gh_id: -1, gh_login: invited_gh_login, name: None, gh_avatar: None, gh_access_token: "some random token", - } - .create_or_update(None, &app.as_inner().emails, &mut conn) - .unwrap(); + }; + + diesel::insert_into(users::table) + .values(user) + .execute(&mut conn) + .unwrap(); CrateBuilder::new(krate_name, owner.id).expect_build(&mut conn); From 48622d58d55f90c76708b44930c983f80c489624 Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Sat, 16 Nov 2024 19:56:13 +0100 Subject: [PATCH 5/6] tests/routes/users/read: Simplify `NewUser` creation There is no need for an "upsert" operation here since we know that the database is in a clean state in our tests. Additionally, this drops the need for the `Emails` implementation, since all we want is a user in the database, but without any email address confirmation emails being sent out. --- src/tests/routes/users/read.rs | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/src/tests/routes/users/read.rs b/src/tests/routes/users/read.rs index e26c6a16a0e..bef99a22486 100644 --- a/src/tests/routes/users/read.rs +++ b/src/tests/routes/users/read.rs @@ -1,6 +1,8 @@ use crate::models::NewUser; +use crate::schema::users; use crate::tests::util::{RequestHelper, TestApp}; use crate::views::EncodablePublicUser; +use diesel::RunQueryDsl; #[derive(Deserialize)] pub struct UserShowPublicResponse { @@ -32,22 +34,26 @@ async fn show_latest_user_case_insensitively() { // should be used for uniquely identifying GitHub accounts whenever possible. For the // crates.io/user/:username pages, the best we can do is show the last crates.io account // created with that username. - assert_ok!(NewUser::new( + + let user1 = NewUser::new( 1, "foobar", Some("I was first then deleted my github account"), None, - "bar" - ) - .create_or_update(None, &app.as_inner().emails, &mut conn)); - assert_ok!(NewUser::new( + "bar", + ); + + let user2 = NewUser::new( 2, "FOOBAR", Some("I was second, I took the foobar username on github"), None, - "bar" - ) - .create_or_update(None, &app.as_inner().emails, &mut conn)); + "bar", + ); + + assert_ok!(diesel::insert_into(users::table) + .values(&vec![user1, user2]) + .execute(&mut conn)); let json: UserShowPublicResponse = anon.get("/api/v1/users/fOObAr").await.good(); assert_eq!( From 0bbb63b0eb7bda91be27b9b5739b4d0bf16e33be Mon Sep 17 00:00:00 2001 From: Tobias Bieniek Date: Sat, 16 Nov 2024 19:56:30 +0100 Subject: [PATCH 6/6] tests/routes/me/email_notifications: Simplify `new_user()` test helper calls There is no need for an "upsert" operation here since we know that the database is in a clean state in our tests. Additionally, this drops the need for the `Emails` implementation, since all we want is a user in the database, but without any email address confirmation emails being sent out. --- src/tests/routes/me/email_notifications.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/tests/routes/me/email_notifications.rs b/src/tests/routes/me/email_notifications.rs index d242834b58d..6612783f211 100644 --- a/src/tests/routes/me/email_notifications.rs +++ b/src/tests/routes/me/email_notifications.rs @@ -1,4 +1,4 @@ -use crate::schema::crate_owners; +use crate::schema::{crate_owners, users}; use crate::tests::builders::CrateBuilder; use crate::tests::new_user; use crate::tests::util::{RequestHelper, TestApp}; @@ -110,11 +110,13 @@ async fn test_update_email_notifications_not_owned() { let (app, _, user) = TestApp::init().with_user(); let mut conn = app.db_conn(); - let u = new_user("arbitrary_username") - .create_or_update(None, &app.as_inner().emails, &mut conn) + let user_id = diesel::insert_into(users::table) + .values(new_user("arbitrary_username")) + .returning(users::id) + .get_result(&mut conn) .unwrap(); - let not_my_crate = CrateBuilder::new("test_package", u.id).expect_build(&mut conn); + let not_my_crate = CrateBuilder::new("test_package", user_id).expect_build(&mut conn); user.update_email_notifications(vec![EmailNotificationsUpdate { id: not_my_crate.id,