tests/util: Replace Response::assert_status() with Response::status()

`Response::status()` is easier to use, slightly less verbose in most cases, and does not hide the implementation details as much.

Author: Turbo87

src/tests/krate/downloads.rs

@@ -37,7 +37,8 @@ fn download() {
 
     let download = |name_and_version: &str| {
         let url = format!("/api/v1/crates/{}/download", name_and_version);
-        anon.get::<()>(&url).assert_status(StatusCode::FOUND);
+        let response = anon.get::<()>(&url);
+        assert_eq!(response.status(), StatusCode::FOUND);
         // TODO: test the with_json code path
     };
 

src/tests/krate/publish.rs

@@ -57,7 +57,7 @@ fn new_wrong_token() {
     // Try to publish without a token
     let crate_to_publish = PublishBuilder::new("foo");
     let response = anon.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::FORBIDDEN);
+    assert_eq!(response.status(), StatusCode::FORBIDDEN);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "must be logged in to perform that action" }] })
@@ -73,7 +73,7 @@ fn new_wrong_token() {
 
     let crate_to_publish = PublishBuilder::new("foo");
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::FORBIDDEN);
+    assert_eq!(response.status(), StatusCode::FORBIDDEN);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "must be logged in to perform that action" }] })
@@ -278,7 +278,7 @@ fn reject_new_crate_with_alternative_registry_dependency() {
 
     let crate_to_publish = PublishBuilder::new("depends-on-alt-registry").dependency(dependency);
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "Dependency `dep` is hosted on another registry. Cross-registry dependencies are not permitted on crates.io." }] })
@@ -301,7 +301,7 @@ fn new_krate_with_wildcard_dependency() {
         .dependency(dependency);
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": WILDCARD_ERROR_MESSAGE }] })
@@ -340,7 +340,7 @@ fn new_krate_wrong_user() {
     let crate_to_publish = PublishBuilder::new("foo_wrong").version("2.0.0");
 
     let response = another_user.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": MISSING_RIGHTS_ERROR_MESSAGE }] })
@@ -355,7 +355,7 @@ fn new_krate_too_big() {
     let builder = PublishBuilder::new("foo_big").files(&files);
 
     let response = user.enqueue_publish(builder);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "uploaded tarball is malformed or too large when decompressed" }] })
@@ -388,7 +388,7 @@ fn new_krate_wrong_files() {
     let builder = PublishBuilder::new("foo").files(&files);
 
     let response = user.enqueue_publish(builder);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "invalid tarball uploaded" }] })
@@ -407,7 +407,7 @@ fn new_krate_gzip_bomb() {
         .files_with_io(&mut [("foo-1.1.0/a", &mut body, len)]);
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "uploaded tarball is malformed or too large when decompressed" }] })
@@ -427,7 +427,7 @@ fn new_krate_duplicate_version() {
 
     let crate_to_publish = PublishBuilder::new("foo_dupe").version("1.0.0");
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "crate version `1.0.0` is already uploaded" }] })
@@ -446,7 +446,7 @@ fn new_crate_similar_name() {
 
     let crate_to_publish = PublishBuilder::new("foo_similar").version("1.1.0");
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "crate was previously named `Foo_similar`" }] })
@@ -465,7 +465,7 @@ fn new_crate_similar_name_hyphen() {
 
     let crate_to_publish = PublishBuilder::new("foo-bar-hyphen").version("1.1.0");
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "crate was previously named `foo_bar_hyphen`" }] })
@@ -484,7 +484,7 @@ fn new_crate_similar_name_underscore() {
 
     let crate_to_publish = PublishBuilder::new("foo_bar_underscore").version("1.1.0");
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "crate was previously named `foo-bar-underscore`" }] })
@@ -557,7 +557,7 @@ fn new_krate_dependency_missing() {
     let crate_to_publish = PublishBuilder::new("foo_missing").dependency(dependency);
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "no known crate named `bar_missing`" }] })
@@ -586,7 +586,7 @@ fn new_krate_without_any_email_fails() {
     let crate_to_publish = PublishBuilder::new("foo_no_email");
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "A verified email address is required to publish crates to crates.io. Visit https://crates.io/me to set and verify your email address." }] })
@@ -607,7 +607,7 @@ fn new_krate_with_unverified_email_fails() {
     let crate_to_publish = PublishBuilder::new("foo_unverified_email");
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "A verified email address is required to publish crates to crates.io. Visit https://crates.io/me to set and verify your email address." }] })
@@ -816,7 +816,7 @@ fn author_license_and_description_required() {
         .unset_authors();
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": missing_metadata_error_message(&["description", "license", "authors"]) }] })
@@ -829,7 +829,7 @@ fn author_license_and_description_required() {
         .author("");
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": missing_metadata_error_message(&["description", "authors"]) }] })
@@ -842,7 +842,7 @@ fn author_license_and_description_required() {
         .unset_description();
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": missing_metadata_error_message(&["description"]) }] })
@@ -869,7 +869,7 @@ fn new_krate_tarball_with_hard_links() {
     let crate_to_publish = PublishBuilder::new("foo").version("1.1.0").tarball(tarball);
 
     let response = token.enqueue_publish(crate_to_publish);
-    response.assert_status(StatusCode::OK);
+    assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(
         response.json(),
         json!({ "errors": [{ "detail": "uploaded tarball is malformed or too large when decompressed" }] })
@@ -888,13 +888,12 @@ fn publish_new_crate_rate_limited() {
 
     // Uploading a second crate is limited
     let crate_to_publish = PublishBuilder::new("rate_limited2");
-    token
-        .enqueue_publish(crate_to_publish)
-        .assert_status(StatusCode::TOO_MANY_REQUESTS);
+    let response = token.enqueue_publish(crate_to_publish);
+    assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
     app.run_pending_background_jobs();
 
-    anon.get::<()>("/api/v1/crates/rate_limited2")
-        .assert_status(StatusCode::NOT_FOUND);
+    let response = anon.get::<()>("/api/v1/crates/rate_limited2");
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
 
     // Wait for the limit to be up
     thread::sleep(Duration::from_millis(500));

src/tests/read_only_mode.rs

@@ -8,8 +8,8 @@ use diesel::prelude::*;
 fn can_hit_read_only_endpoints_in_read_only_mode() {
     let (app, anon) = TestApp::init().empty();
     app.db(set_read_only).unwrap();
-    anon.get::<()>("/api/v1/crates")
-        .assert_status(StatusCode::OK);
+    let response = anon.get::<()>("/api/v1/crates");
+    assert_eq!(response.status(), StatusCode::OK);
 }
 
 #[test]
@@ -21,9 +21,9 @@ fn cannot_hit_endpoint_which_writes_db_in_read_only_mode() {
             .expect_build(conn);
         set_read_only(conn).unwrap();
     });
-    token
-        .delete::<()>("/api/v1/crates/foo_yank_read_only/1.0.0/yank")
-        .assert_status(StatusCode::SERVICE_UNAVAILABLE);
+
+    let response = token.delete::<()>("/api/v1/crates/foo_yank_read_only/1.0.0/yank");
+    assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
 
     // Restore the transaction so `TestApp::drop` can still access the transaction
     app.db(|conn| {
@@ -44,8 +44,8 @@ fn can_download_crate_in_read_only_mode() {
         set_read_only(conn).unwrap();
     });
 
-    anon.get::<()>("/api/v1/crates/foo_download_read_only/1.0.0/download")
-        .assert_status(StatusCode::FOUND);
+    let response = anon.get::<()>("/api/v1/crates/foo_download_read_only/1.0.0/download");
+    assert_eq!(response.status(), StatusCode::FOUND);
 
     // We're in read only mode so the download should not have been counted
     app.db(|conn| {

src/tests/server.rs

@@ -10,7 +10,7 @@ fn user_agent_is_required() {
     let mut req = anon.request_builder(Method::GET, "/api/v1/crates");
     req.header(header::USER_AGENT, "");
     let resp = anon.run::<()>(req);
-    resp.assert_status(StatusCode::FORBIDDEN);
+    assert_eq!(resp.status(), StatusCode::FORBIDDEN);
 }
 
 #[test]
@@ -24,7 +24,7 @@ fn user_agent_is_not_required_for_download() {
     let mut req = anon.request_builder(Method::GET, "/api/v1/crates/dl_no_ua/0.99.0/download");
     req.header(header::USER_AGENT, "");
     let resp = anon.run::<()>(req);
-    resp.assert_status(StatusCode::FOUND);
+    assert_eq!(resp.status(), StatusCode::FOUND);
 }
 
 #[test]
@@ -42,7 +42,7 @@ fn blocked_traffic_doesnt_panic_if_checked_header_is_not_present() {
     let mut req = anon.request_builder(Method::GET, "/api/v1/crates/dl_no_ua/0.99.0/download");
     req.header(header::USER_AGENT, "");
     let resp = anon.run::<()>(req);
-    resp.assert_status(StatusCode::FOUND);
+    assert_eq!(resp.status(), StatusCode::FOUND);
 }
 
 #[test]
@@ -67,7 +67,7 @@ fn block_traffic_via_arbitrary_header_and_value() {
         "abcd",
     );
     let resp = anon.run::<()>(req);
-    resp.assert_status(StatusCode::FORBIDDEN);
+    assert_eq!(resp.status(), StatusCode::FORBIDDEN);
 
     let mut req = anon.request_builder(Method::GET, "/api/v1/crates/dl_no_ua/0.99.0/download");
     // A request with a header value we don't want to block is allowed, even though there might
@@ -77,5 +77,5 @@ fn block_traffic_via_arbitrary_header_and_value() {
         "1value-must-match-exactly-this-is-allowed",
     );
     let resp = anon.run::<()>(req);
-    resp.assert_status(StatusCode::FOUND);
+    assert_eq!(resp.status(), StatusCode::FOUND);
 }

src/tests/util.rs

@@ -596,8 +596,8 @@ where
     /// Assert that the response is good and deserialize the message
     #[track_caller]
     pub fn good(mut self) -> T {
-        if !self.response.status().is_success() {
-            panic!("bad response: {:?}", self.response.status());
+        if !self.status().is_success() {
+            panic!("bad response: {:?}", self.status());
         }
         crate::json(&mut self.response)
     }
@@ -607,17 +607,15 @@ where
     /// Cargo endpoints return a status 200 on error instead of 400.
     #[track_caller]
     pub fn bad_with_status(&mut self, expected: StatusCode) -> Bad {
-        assert_eq!(self.response.status(), expected);
+        assert_eq!(self.status(), expected);
         match crate::bad_resp(&mut self.response) {
-            None => panic!("ok response: {:?}", self.response.status()),
+            None => panic!("ok response: {:?}", self.status()),
             Some(b) => b,
         }
     }
 
-    #[track_caller]
-    pub fn assert_status(&self, status: StatusCode) -> &Self {
-        assert_eq!(status, self.response.status());
-        self
+    pub fn status(&self) -> StatusCode {
+        self.response.status()
     }
 
     #[track_caller]
@@ -638,12 +636,12 @@ impl Response<()> {
     /// Assert that the status code is 404
     #[track_caller]
     pub fn assert_not_found(&self) {
-        assert_eq!(StatusCode::NOT_FOUND, self.response.status());
+        assert_eq!(StatusCode::NOT_FOUND, self.status());
     }
 
     /// Assert that the status code is 403
     #[track_caller]
     pub fn assert_forbidden(&self) {
-        assert_eq!(StatusCode::FORBIDDEN, self.response.status());
+        assert_eq!(StatusCode::FORBIDDEN, self.status());
     }
 }