Merge pull request #10057 from Turbo87/result-tests

Simplify tests by returning Result from test fns

Author: Turbo87

src/tests/dump_db.rs

@@ -14,15 +14,15 @@ static PATH_DATE_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^\d{4}-\d{2}-\d{2}-\d{6}").unwrap());
 
 #[tokio::test(flavor = "multi_thread")]
-async fn test_dump_db_job() {
+async fn test_dump_db_job() -> anyhow::Result<()> {
     let (app, _, _, token) = TestApp::full().with_token().await;
     let mut conn = app.db_conn().await;
 
     CrateBuilder::new("test-crate", token.as_model().user_id)
         .expect_build(&mut conn)
         .await;
 
-    DumpDb.enqueue(&mut conn).await.unwrap();
+    DumpDb.enqueue(&mut conn).await?;
 
     app.run_pending_background_jobs().await;
 
@@ -31,9 +31,9 @@ async fn test_dump_db_job() {
     db-dump.zip
     ");
 
-    let path = object_store::path::Path::parse("db-dump.tar.gz").unwrap();
-    let result = app.as_inner().storage.as_inner().get(&path).await.unwrap();
-    let bytes = result.bytes().await.unwrap();
+    let path = object_store::path::Path::parse("db-dump.tar.gz")?;
+    let result = app.as_inner().storage.as_inner().get(&path).await?;
+    let bytes = result.bytes().await?;
 
     let gz = GzDecoder::new(bytes.reader());
     let mut tar = Archive::new(gz);
@@ -66,11 +66,11 @@ async fn test_dump_db_job() {
     ]
     "#);
 
-    let path = object_store::path::Path::parse("db-dump.zip").unwrap();
-    let result = app.as_inner().storage.as_inner().get(&path).await.unwrap();
-    let bytes = result.bytes().await.unwrap();
+    let path = object_store::path::Path::parse("db-dump.zip")?;
+    let result = app.as_inner().storage.as_inner().get(&path).await?;
+    let bytes = result.bytes().await?;
 
-    let archive = zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
+    let archive = zip::ZipArchive::new(Cursor::new(bytes))?;
     let zip_paths = archive.file_names().collect::<Vec<_>>();
     assert_debug_snapshot!(zip_paths, @r#"
     [
@@ -97,6 +97,8 @@ async fn test_dump_db_job() {
         "data/version_downloads.csv",
     ]
     "#);
+
+    Ok(())
 }
 
 fn tar_paths<R: Read>(archive: &mut Archive<R>) -> Vec<String> {

src/tests/owners.rs

@@ -216,7 +216,7 @@ async fn owners_can_remove_self() {
 
 /// Verify consistency when adidng or removing multiple owners in a single request.
 #[tokio::test(flavor = "multi_thread")]
-async fn modify_multiple_owners() {
+async fn modify_multiple_owners() -> anyhow::Result<()> {
     let (app, _, user, token) = TestApp::init().with_token().await;
     let mut conn = app.db_conn().await;
     let username = &user.as_model().gh_login;
@@ -236,23 +236,23 @@ 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).await.unwrap().len(), 3);
+    assert_eq!(krate.owners(&mut conn).await?.len(), 3);
 
     // Deleting two owners at once is allowed.
     let response = token
         .remove_named_owners("owners_multiple", &["user2", "user3"])
         .await;
     assert_eq!(response.status(), StatusCode::OK);
     assert_snapshot!(response.text(), @r#"{"msg":"owners successfully removed","ok":true}"#);
-    assert_eq!(krate.owners(&mut conn).await.unwrap().len(), 1);
+    assert_eq!(krate.owners(&mut conn).await?.len(), 1);
 
     // Adding multiple users fails if one of them already is an owner.
     let response = token
         .add_named_owners("owners_multiple", &["user2", username])
         .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).await.unwrap().len(), 1);
+    assert_eq!(krate.owners(&mut conn).await?.len(), 1);
 
     // Adding multiple users at once succeeds.
     let response = token
@@ -270,7 +270,9 @@ async fn modify_multiple_owners() {
         .accept_ownership_invitation(&krate.name, krate.id)
         .await;
 
-    assert_eq!(krate.owners(&mut conn).await.unwrap().len(), 3);
+    assert_eq!(krate.owners(&mut conn).await?.len(), 3);
+
+    Ok(())
 }
 
 /// Testing the crate ownership between two crates and one team.
@@ -280,21 +282,16 @@ async fn modify_multiple_owners() {
 /// and that the CrateList returned for the team_id contains
 /// only crates owned by that team.
 #[tokio::test(flavor = "multi_thread")]
-async fn check_ownership_two_crates() {
+async fn check_ownership_two_crates() -> anyhow::Result<()> {
     let (app, anon, user) = TestApp::init().with_user().await;
     let mut conn = app.db_conn().await;
     let user = user.as_model();
 
-    let team = new_team("team_foo")
-        .create_or_update(&mut conn)
-        .await
-        .unwrap();
+    let team = new_team("team_foo").create_or_update(&mut conn).await?;
     let krate_owned_by_team = CrateBuilder::new("foo", user.id)
         .expect_build(&mut conn)
         .await;
-    add_team_to_crate(&team, &krate_owned_by_team, user, &mut conn)
-        .await
-        .unwrap();
+    add_team_to_crate(&team, &krate_owned_by_team, user, &mut conn).await?;
 
     let user2 = app.db_new_user("user_bar").await;
     let user2 = user2.as_model();
@@ -310,6 +307,8 @@ async fn check_ownership_two_crates() {
     let json = anon.search(&query).await;
     assert_eq!(json.crates.len(), 1);
     assert_eq!(json.crates[0].name, krate_owned_by_team.name);
+
+    Ok(())
 }
 
 /// Given a crate owned by both a team and a user, check that the
@@ -320,21 +319,18 @@ async fn check_ownership_two_crates() {
 /// of form github:org_name:team_name as that is the format
 /// EncodableOwner::encodable is expecting
 #[tokio::test(flavor = "multi_thread")]
-async fn check_ownership_one_crate() {
+async fn check_ownership_one_crate() -> anyhow::Result<()> {
     let (app, anon, user) = TestApp::init().with_user().await;
     let mut conn = app.db_conn().await;
     let user = user.as_model();
 
     let team = new_team("github:test_org:team_sloth")
         .create_or_update(&mut conn)
-        .await
-        .unwrap();
+        .await?;
     let krate = CrateBuilder::new("best_crate", user.id)
         .expect_build(&mut conn)
         .await;
-    add_team_to_crate(&team, &krate, user, &mut conn)
-        .await
-        .unwrap();
+    add_team_to_crate(&team, &krate, user, &mut conn).await?;
 
     let json: TeamResponse = anon
         .get("/api/v1/crates/best_crate/owner_team")
@@ -349,6 +345,8 @@ async fn check_ownership_one_crate() {
         .good();
     assert_eq!(json.users[0].kind, "user");
     assert_eq!(json.users[0].name, user.name);
+
+    Ok(())
 }
 
 /// Assert the error response when attempting to add a team as a crate owner

src/tests/routes/categories/get.rs

@@ -9,7 +9,7 @@ use insta::assert_json_snapshot;
 use serde_json::Value;
 
 #[tokio::test(flavor = "multi_thread")]
-async fn show() {
+async fn show() -> anyhow::Result<()> {
     let (app, anon) = TestApp::init().empty().await;
     let mut conn = app.db_conn().await;
 
@@ -24,23 +24,23 @@ async fn show() {
         new_category("Foo Bar::Baz", "foo-bar::baz", "Baz crates"),
     ];
 
-    assert_ok!(
-        insert_into(categories::table)
-            .values(cats)
-            .execute(&mut conn)
-            .await
-    );
+    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();
     assert_json_snapshot!(json, {
         ".**.created_at" => "[datetime]",
     });
+
+    Ok(())
 }
 
 #[tokio::test(flavor = "multi_thread")]
 #[allow(clippy::cognitive_complexity)]
-async fn update_crate() {
+async fn update_crate() -> anyhow::Result<()> {
     // Convenience function to get the number of crates in a category
     async fn count(anon: &MockAnonymousUser, category: &str) -> usize {
         let json = anon.show_category(category).await;
@@ -68,51 +68,38 @@ async fn update_crate() {
         .await;
 
     // Updating with no categories has no effect
-    Category::update_crate(&mut conn, krate.id, &[])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &[]).await?;
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Happy path adding one category
-    Category::update_crate(&mut conn, krate.id, &["cat1"])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &["cat1"]).await?;
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Replacing one category with another
-    Category::update_crate(&mut conn, krate.id, &["category-2"])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &["category-2"]).await?;
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 1);
 
     // Removing one category
-    Category::update_crate(&mut conn, krate.id, &[])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &[]).await?;
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
     // Adding 2 categories
-    Category::update_crate(&mut conn, krate.id, &["cat1", "category-2"])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &["cat1", "category-2"]).await?;
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "category-2").await, 1);
 
     // Removing all categories
-    Category::update_crate(&mut conn, krate.id, &[])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &[]).await?;
     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 conn, krate.id, &["cat1", "catnope"])
-        .await
-        .unwrap();
+    let invalid_categories =
+        Category::update_crate(&mut conn, krate.id, &["cat1", "catnope"]).await?;
     assert_eq!(invalid_categories, vec!["catnope"]);
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "category-2").await, 0);
@@ -124,9 +111,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 conn, krate.id, &["Category 2"])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &["Category 2"]).await?;
     assert_eq!(count(&anon, "cat1").await, 0);
     assert_eq!(count(&anon, "category-2").await, 0);
 
@@ -138,11 +123,11 @@ async fn update_crate() {
             .await
     );
 
-    Category::update_crate(&mut conn, krate.id, &["cat1", "cat1::bar"])
-        .await
-        .unwrap();
+    Category::update_crate(&mut conn, krate.id, &["cat1", "cat1::bar"]).await?;
 
     assert_eq!(count(&anon, "cat1").await, 1);
     assert_eq!(count(&anon, "cat1::bar").await, 1);
     assert_eq!(count(&anon, "category-2").await, 0);
+
+    Ok(())
 }