chore: fix new clippy lints v2.x

Fishrock123 · Fishrock123 · commit b3fa1dbe8d00 · 2021-04-07T11:33:44.000-07:00
From some newer version of rust (mostly 1.51).
diff --git a/src/auth/authorization.rs b/src/auth/authorization.rs
@@ -132,11 +132,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(AUTHORIZATION, "<nori ate the tag. yum.>");
         let err = Authorization::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/auth/basic_auth.rs b/src/auth/basic_auth.rs
@@ -135,11 +135,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(AUTHORIZATION, "<nori ate the tag. yum.>");
         let err = BasicAuth::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/auth/www_authenticate.rs b/src/auth/www_authenticate.rs
@@ -159,11 +159,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(WWW_AUTHENTICATE, "<nori ate the tag. yum.>");
         let err = WwwAuthenticate::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/cache/age.rs b/src/cache/age.rs
@@ -113,11 +113,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(AGE, "<nori ate the tag. yum.>");
         let err = Age::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/cache/cache_control/mod.rs b/src/cache/cache_control/mod.rs
@@ -45,11 +45,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(CACHE_CONTROL, "min-fresh=0.9"); // floats are not supported
         let err = CacheControl::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/cache/expires.rs b/src/cache/expires.rs
@@ -120,11 +120,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(EXPIRES, "<nori ate the tag. yum.>");
         let err = Expires::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/conditional/etag.rs b/src/conditional/etag.rs
@@ -177,21 +177,19 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(ETAG, "<nori ate the tag. yum.>");
         let err = ETag::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 
     #[test]
-    fn validate_quotes() -> crate::Result<()> {
+    fn validate_quotes() {
         assert_entry_err(r#""hello"#, "Invalid ETag header");
         assert_entry_err(r#"hello""#, "Invalid ETag header");
         assert_entry_err(r#"/O"valid content""#, "Invalid ETag header");
         assert_entry_err(r#"/Wvalid content""#, "Invalid ETag header");
-        Ok(())
     }
 
     fn assert_entry_err(s: &str, msg: &str) {
@@ -202,9 +200,8 @@ mod test {
     }
 
     #[test]
-    fn validate_characters() -> crate::Result<()> {
+    fn validate_characters() {
         assert_entry_err(r#"""hello""#, "Invalid ETag header");
         assert_entry_err("\"hello\x7F\"", "Invalid ETag header");
-        Ok(())
     }
 }
diff --git a/src/conditional/if_modified_since.rs b/src/conditional/if_modified_since.rs
@@ -116,11 +116,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(IF_MODIFIED_SINCE, "<nori ate the tag. yum.>");
         let err = IfModifiedSince::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/conditional/if_unmodified_since.rs b/src/conditional/if_unmodified_since.rs
@@ -116,11 +116,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(IF_UNMODIFIED_SINCE, "<nori ate the tag. yum.>");
         let err = IfUnmodifiedSince::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/conditional/last_modified.rs b/src/conditional/last_modified.rs
@@ -115,11 +115,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(LAST_MODIFIED, "<nori ate the tag. yum.>");
         let err = LastModified::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/content/content_length.rs b/src/content/content_length.rs
@@ -98,11 +98,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(CONTENT_LENGTH, "<nori ate the tag. yum.>");
         let err = ContentLength::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/content/content_location.rs b/src/content/content_location.rs
@@ -122,13 +122,12 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(CONTENT_LOCATION, "htt://<nori ate the tag. yum.>");
         let err =
             ContentLocation::from_headers(Url::parse("https://example.net").unwrap(), headers)
                 .unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/content/content_type.rs b/src/content/content_type.rs
@@ -130,11 +130,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(CONTENT_TYPE, "<nori ate the tag. yum.>");
         let err = ContentType::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/content/encoding_proposal.rs b/src/content/encoding_proposal.rs
@@ -123,15 +123,14 @@ mod test {
     use super::*;
 
     #[test]
-    fn smoke() -> crate::Result<()> {
+    fn smoke() {
         let _ = EncodingProposal::new(Encoding::Gzip, Some(0.0)).unwrap();
         let _ = EncodingProposal::new(Encoding::Gzip, Some(0.5)).unwrap();
         let _ = EncodingProposal::new(Encoding::Gzip, Some(1.0)).unwrap();
-        Ok(())
     }
 
     #[test]
-    fn error_code_500() -> crate::Result<()> {
+    fn error_code_500() {
         let err = EncodingProposal::new(Encoding::Gzip, Some(1.1)).unwrap_err();
         assert_eq!(err.status(), 500);
 
@@ -140,6 +139,5 @@ mod test {
 
         let err = EncodingProposal::new(Encoding::Gzip, Some(-0.0)).unwrap_err();
         assert_eq!(err.status(), 500);
-        Ok(())
     }
 }
diff --git a/src/content/media_type_proposal.rs b/src/content/media_type_proposal.rs
@@ -57,7 +57,7 @@ impl MediaTypeProposal {
             .remove_param("q")
             .map(|param| param.as_str().parse())
             .transpose()?;
-        Ok(Self::new(media_type, weight)?)
+        Self::new(media_type, weight)
     }
 }
 
@@ -135,15 +135,14 @@ mod test {
     use crate::mime;
 
     #[test]
-    fn smoke() -> crate::Result<()> {
+    fn smoke() {
         let _ = MediaTypeProposal::new(mime::JSON, Some(0.0)).unwrap();
         let _ = MediaTypeProposal::new(mime::XML, Some(0.5)).unwrap();
         let _ = MediaTypeProposal::new(mime::HTML, Some(1.0)).unwrap();
-        Ok(())
     }
 
     #[test]
-    fn error_code_500() -> crate::Result<()> {
+    fn error_code_500() {
         let err = MediaTypeProposal::new(mime::JSON, Some(1.1)).unwrap_err();
         assert_eq!(err.status(), 500);
 
@@ -152,6 +151,5 @@ mod test {
 
         let err = MediaTypeProposal::new(mime::HTML, Some(-0.0)).unwrap_err();
         assert_eq!(err.status(), 500);
-        Ok(())
     }
 }
diff --git a/src/method.rs b/src/method.rs
@@ -518,9 +518,8 @@ mod test {
     }
 
     #[test]
-    fn serde_fail() -> Result<(), serde_json::Error> {
+    fn serde_fail() {
         serde_json::from_str::<Method>("\"ABC\"").expect_err("Did deserialize from invalid string");
-        Ok(())
     }
 
     #[test]
diff --git a/src/other/date.rs b/src/other/date.rs
@@ -132,11 +132,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(DATE, "<nori ate the tag. yum.>");
         let err = Date::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/other/expect.rs b/src/other/expect.rs
@@ -100,11 +100,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(EXPECT, "<nori ate the tag. yum.>");
         let err = Expect::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/other/referer.rs b/src/other/referer.rs
@@ -126,13 +126,12 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(REFERER, "htt://<nori ate the tag. yum.>");
         let err =
             Referer::from_headers(Url::parse("https://example.net").unwrap(), headers).unwrap_err();
         assert_eq!(err.status(), 500);
-        Ok(())
     }
 
     #[test]
diff --git a/src/other/source_map.rs b/src/other/source_map.rs
@@ -123,13 +123,12 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(SOURCE_MAP, "htt://<nori ate the tag. yum.>");
         let err = SourceMap::from_headers(Url::parse("https://example.net").unwrap(), headers)
             .unwrap_err();
         assert_eq!(err.status(), 500);
-        Ok(())
     }
 
     #[test]
diff --git a/src/proxies/forwarded.rs b/src/proxies/forwarded.rs
@@ -455,14 +455,14 @@ impl std::fmt::Display for Forwarded<'_> {
 impl ToHeaderValues for Forwarded<'_> {
     type Iter = std::option::IntoIter<HeaderValue>;
     fn to_header_values(&self) -> crate::Result<Self::Iter> {
-        Ok(self.value()?.to_header_values()?)
+        self.value()?.to_header_values()
     }
 }
 
 impl ToHeaderValues for &Forwarded<'_> {
     type Iter = std::option::IntoIter<HeaderValue>;
     fn to_header_values(&self) -> crate::Result<Self::Iter> {
-        Ok(self.value()?.to_header_values()?)
+        self.value()?.to_header_values()
     }
 }
 
@@ -550,7 +550,7 @@ mod tests {
     }
 
     #[test]
-    fn bad_parse() -> Result<()> {
+    fn bad_parse() {
         let err = Forwarded::parse("by=proxy.com;for=client;host=example.com;host").unwrap_err();
         assert_eq!(
             err.to_string(),
@@ -580,7 +580,6 @@ mod tests {
             err.to_string(),
             "unable to parse forwarded header: for= without valid value"
         );
-        Ok(())
     }
 
     #[test]
@@ -611,15 +610,14 @@ mod tests {
     }
 
     #[test]
-    fn formatting_edge_cases() -> Result<()> {
+    fn formatting_edge_cases() {
         let mut forwarded = Forwarded::new();
         forwarded.add_for(r#"quote: " backslash: \"#);
         forwarded.add_for(";proto=https");
         assert_eq!(
             forwarded.to_string(),
             r#"for="quote: \" backslash: \\", for=";proto=https""#
         );
-        Ok(())
     }
 
     #[test]
diff --git a/src/security/timing_allow_origin.rs b/src/security/timing_allow_origin.rs
@@ -308,12 +308,11 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(TIMING_ALLOW_ORIGIN, "server; <nori ate your param omnom>");
         let err = TimingAllowOrigin::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 
     #[test]
diff --git a/src/trace/server_timing/mod.rs b/src/trace/server_timing/mod.rs
@@ -262,11 +262,10 @@ mod test {
     }
 
     #[test]
-    fn bad_request_on_parse_error() -> crate::Result<()> {
+    fn bad_request_on_parse_error() {
         let mut headers = Headers::new();
         headers.insert(SERVER_TIMING, "server; <nori ate your param omnom>");
         let err = ServerTiming::from_headers(headers).unwrap_err();
         assert_eq!(err.status(), 400);
-        Ok(())
     }
 }
diff --git a/src/trace/trace_context.rs b/src/trace/trace_context.rs
diff --git a/src/transfer/encoding_proposal.rs b/src/transfer/encoding_proposal.rs
diff --git a/src/transfer/te.rs b/src/transfer/te.rs

Original file line number	Diff line number	Diff line change
`@@ -132,11 +132,10 @@ mod test {`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`#[test]`
`135`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`135`	`+ fn bad_request_on_parse_error() {`
`136`	`136`	`let mut headers = Headers::new();`
`137`	`137`	`headers.insert(AUTHORIZATION, "<nori ate the tag. yum.>");`
`138`	`138`	`let err = Authorization::from_headers(headers).unwrap_err();`
`139`	`139`	`assert_eq!(err.status(), 400);`
`140`		`- Ok(())`
`141`	`140`	`}`
`142`	`141`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,11 +135,10 @@ mod test {`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`#[test]`
`138`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`138`	`+ fn bad_request_on_parse_error() {`
`139`	`139`	`let mut headers = Headers::new();`
`140`	`140`	`headers.insert(AUTHORIZATION, "<nori ate the tag. yum.>");`
`141`	`141`	`let err = BasicAuth::from_headers(headers).unwrap_err();`
`142`	`142`	`assert_eq!(err.status(), 400);`
`143`		`- Ok(())`
`144`	`143`	`}`
`145`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -159,11 +159,10 @@ mod test {`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`#[test]`
`162`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`162`	`+ fn bad_request_on_parse_error() {`
`163`	`163`	`let mut headers = Headers::new();`
`164`	`164`	`headers.insert(WWW_AUTHENTICATE, "<nori ate the tag. yum.>");`
`165`	`165`	`let err = WwwAuthenticate::from_headers(headers).unwrap_err();`
`166`	`166`	`assert_eq!(err.status(), 400);`
`167`		`- Ok(())`
`168`	`167`	`}`
`169`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,11 +113,10 @@ mod test {`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`#[test]`
`116`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`116`	`+ fn bad_request_on_parse_error() {`
`117`	`117`	`let mut headers = Headers::new();`
`118`	`118`	`headers.insert(AGE, "<nori ate the tag. yum.>");`
`119`	`119`	`let err = Age::from_headers(headers).unwrap_err();`
`120`	`120`	`assert_eq!(err.status(), 400);`
`121`		`- Ok(())`
`122`	`121`	`}`
`123`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,11 +45,10 @@ mod test {`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`#[test]`
`48`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`48`	`+ fn bad_request_on_parse_error() {`
`49`	`49`	`let mut headers = Headers::new();`
`50`	`50`	`headers.insert(CACHE_CONTROL, "min-fresh=0.9"); // floats are not supported`
`51`	`51`	`let err = CacheControl::from_headers(headers).unwrap_err();`
`52`	`52`	`assert_eq!(err.status(), 400);`
`53`		`- Ok(())`
`54`	`53`	`}`
`55`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,11 +120,10 @@ mod test {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`#[test]`
`123`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`123`	`+ fn bad_request_on_parse_error() {`
`124`	`124`	`let mut headers = Headers::new();`
`125`	`125`	`headers.insert(EXPIRES, "<nori ate the tag. yum.>");`
`126`	`126`	`let err = Expires::from_headers(headers).unwrap_err();`
`127`	`127`	`assert_eq!(err.status(), 400);`
`128`		`- Ok(())`
`129`	`128`	`}`
`130`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -177,21 +177,19 @@ mod test {`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`#[test]`
`180`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`180`	`+ fn bad_request_on_parse_error() {`
`181`	`181`	`let mut headers = Headers::new();`
`182`	`182`	`headers.insert(ETAG, "<nori ate the tag. yum.>");`
`183`	`183`	`let err = ETag::from_headers(headers).unwrap_err();`
`184`	`184`	`assert_eq!(err.status(), 400);`
`185`		`- Ok(())`
`186`	`185`	`}`
`187`	`186`
`188`	`187`	`#[test]`
`189`		`- fn validate_quotes() -> crate::Result<()> {`
	`188`	`+ fn validate_quotes() {`
`190`	`189`	`assert_entry_err(r#""hello"#, "Invalid ETag header");`
`191`	`190`	`assert_entry_err(r#"hello""#, "Invalid ETag header");`
`192`	`191`	`assert_entry_err(r#"/O"valid content""#, "Invalid ETag header");`
`193`	`192`	`assert_entry_err(r#"/Wvalid content""#, "Invalid ETag header");`
`194`		`- Ok(())`
`195`	`193`	`}`
`196`	`194`
`197`	`195`	`fn assert_entry_err(s: &str, msg: &str) {`
`@@ -202,9 +200,8 @@ mod test {`
`202`	`200`	`}`
`203`	`201`
`204`	`202`	`#[test]`
`205`		`- fn validate_characters() -> crate::Result<()> {`
	`203`	`+ fn validate_characters() {`
`206`	`204`	`assert_entry_err(r#"""hello""#, "Invalid ETag header");`
`207`	`205`	`assert_entry_err("\"hello\x7F\"", "Invalid ETag header");`
`208`		`- Ok(())`
`209`	`206`	`}`
`210`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,11 +116,10 @@ mod test {`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`#[test]`
`119`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`119`	`+ fn bad_request_on_parse_error() {`
`120`	`120`	`let mut headers = Headers::new();`
`121`	`121`	`headers.insert(IF_MODIFIED_SINCE, "<nori ate the tag. yum.>");`
`122`	`122`	`let err = IfModifiedSince::from_headers(headers).unwrap_err();`
`123`	`123`	`assert_eq!(err.status(), 400);`
`124`		`- Ok(())`
`125`	`124`	`}`
`126`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,11 +115,10 @@ mod test {`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`#[test]`
`118`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`118`	`+ fn bad_request_on_parse_error() {`
`119`	`119`	`let mut headers = Headers::new();`
`120`	`120`	`headers.insert(LAST_MODIFIED, "<nori ate the tag. yum.>");`
`121`	`121`	`let err = LastModified::from_headers(headers).unwrap_err();`
`122`	`122`	`assert_eq!(err.status(), 400);`
`123`		`- Ok(())`
`124`	`123`	`}`
`125`	`124`	`}`