tests: Avoid NewUser::create_or_update() calls

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<i32> {
         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(

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

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

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,

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!(

src/worker/jobs/downloads/update_metadata.rs

@@ -105,14 +105,15 @@ fn batch_update(batch_size: i64, conn: &mut impl Conn) -> QueryResult<i64> {
 #[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()
     }