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

@@ -910,13 +910,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

@@ -590,8 +590,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)
     }
@@ -601,17 +601,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]
@@ -632,12 +630,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());
     }
 }