Merge pull request #338 from http-rs/fix-clippy-lints

yoshuawuyts · web-flow · commit 2bbadb24a1b5 · 2021-02-23T16:36:07.000+01:00
Fix clippy lints
diff --git a/src/auth/authorization.rs b/src/auth/authorization.rs
@@ -142,11 +142,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
@@ -145,11 +145,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
@@ -169,11 +169,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
@@ -123,11 +123,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
@@ -129,11 +129,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
@@ -186,21 +186,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) {
@@ -211,9 +209,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
@@ -125,11 +125,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
@@ -125,11 +125,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
@@ -124,11 +124,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
@@ -107,11 +107,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
@@ -131,13 +131,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
@@ -140,11 +140,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
@@ -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
@@ -160,8 +160,7 @@ mod test {
         Ok(())
     }
     #[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(())
     }
 }
diff --git a/src/other/date.rs b/src/other/date.rs
@@ -141,11 +141,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
@@ -109,11 +109,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
@@ -135,13 +135,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
@@ -132,13 +132,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
@@ -562,7 +562,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(),
@@ -592,7 +592,6 @@ mod tests {
             err.to_string(),
             "unable to parse forwarded header: for= without valid value"
         );
-        Ok(())
     }
 
     #[test]
@@ -623,15 +622,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
@@ -317,12 +317,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
@@ -271,11 +271,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
@@ -283,13 +283,12 @@ mod test {
     }
 
     #[test]
-    fn no_header() -> crate::Result<()> {
+    fn no_header() {
         let context = TraceContext::new();
         assert_eq!(context.version(), 0);
         assert_eq!(context.parent_id(), None);
         assert_eq!(context.flags, 1);
         assert_eq!(context.sampled(), true);
-        Ok(())
     }
 
     #[test]
diff --git a/src/transfer/encoding_proposal.rs b/src/transfer/encoding_proposal.rs

Original file line number	Diff line number	Diff line change
`@@ -142,11 +142,10 @@ mod test {`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`#[test]`
`145`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`145`	`+ fn bad_request_on_parse_error() {`
`146`	`146`	`let mut headers = Headers::new();`
`147`	`147`	`headers.insert(AUTHORIZATION, "<nori ate the tag. yum.>");`
`148`	`148`	`let err = Authorization::from_headers(headers).unwrap_err();`
`149`	`149`	`assert_eq!(err.status(), 400);`
`150`		`- Ok(())`
`151`	`150`	`}`
`152`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,11 +145,10 @@ mod test {`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`#[test]`
`148`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`148`	`+ fn bad_request_on_parse_error() {`
`149`	`149`	`let mut headers = Headers::new();`
`150`	`150`	`headers.insert(AUTHORIZATION, "<nori ate the tag. yum.>");`
`151`	`151`	`let err = BasicAuth::from_headers(headers).unwrap_err();`
`152`	`152`	`assert_eq!(err.status(), 400);`
`153`		`- Ok(())`
`154`	`153`	`}`
`155`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -169,11 +169,10 @@ mod test {`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`#[test]`
`172`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`172`	`+ fn bad_request_on_parse_error() {`
`173`	`173`	`let mut headers = Headers::new();`
`174`	`174`	`headers.insert(WWW_AUTHENTICATE, "<nori ate the tag. yum.>");`
`175`	`175`	`let err = WwwAuthenticate::from_headers(headers).unwrap_err();`
`176`	`176`	`assert_eq!(err.status(), 400);`
`177`		`- Ok(())`
`178`	`177`	`}`
`179`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,11 +123,10 @@ mod test {`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`#[test]`
`126`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`126`	`+ fn bad_request_on_parse_error() {`
`127`	`127`	`let mut headers = Headers::new();`
`128`	`128`	`headers.insert(AGE, "<nori ate the tag. yum.>");`
`129`	`129`	`let err = Age::from_headers(headers).unwrap_err();`
`130`	`130`	`assert_eq!(err.status(), 400);`
`131`		`- Ok(())`
`132`	`131`	`}`
`133`	`132`	`}`
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
`@@ -129,11 +129,10 @@ mod test {`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`#[test]`
`132`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`132`	`+ fn bad_request_on_parse_error() {`
`133`	`133`	`let mut headers = Headers::new();`
`134`	`134`	`headers.insert(EXPIRES, "<nori ate the tag. yum.>");`
`135`	`135`	`let err = Expires::from_headers(headers).unwrap_err();`
`136`	`136`	`assert_eq!(err.status(), 400);`
`137`		`- Ok(())`
`138`	`137`	`}`
`139`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -186,21 +186,19 @@ mod test {`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`#[test]`
`189`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`189`	`+ fn bad_request_on_parse_error() {`
`190`	`190`	`let mut headers = Headers::new();`
`191`	`191`	`headers.insert(ETAG, "<nori ate the tag. yum.>");`
`192`	`192`	`let err = ETag::from_headers(headers).unwrap_err();`
`193`	`193`	`assert_eq!(err.status(), 400);`
`194`		`- Ok(())`
`195`	`194`	`}`
`196`	`195`
`197`	`196`	`#[test]`
`198`		`- fn validate_quotes() -> crate::Result<()> {`
	`197`	`+ fn validate_quotes() {`
`199`	`198`	`assert_entry_err(r#""hello"#, "Invalid ETag header");`
`200`	`199`	`assert_entry_err(r#"hello""#, "Invalid ETag header");`
`201`	`200`	`assert_entry_err(r#"/O"valid content""#, "Invalid ETag header");`
`202`	`201`	`assert_entry_err(r#"/Wvalid content""#, "Invalid ETag header");`
`203`		`- Ok(())`
`204`	`202`	`}`
`205`	`203`
`206`	`204`	`fn assert_entry_err(s: &str, msg: &str) {`
`@@ -211,9 +209,8 @@ mod test {`
`211`	`209`	`}`
`212`	`210`
`213`	`211`	`#[test]`
`214`		`- fn validate_characters() -> crate::Result<()> {`
	`212`	`+ fn validate_characters() {`
`215`	`213`	`assert_entry_err(r#"""hello""#, "Invalid ETag header");`
`216`	`214`	`assert_entry_err("\"hello\x7F\"", "Invalid ETag header");`
`217`		`- Ok(())`
`218`	`215`	`}`
`219`	`216`	`}`
Original file line number	Diff line number	Diff line change
`@@ -125,11 +125,10 @@ mod test {`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`#[test]`
`128`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`128`	`+ fn bad_request_on_parse_error() {`
`129`	`129`	`let mut headers = Headers::new();`
`130`	`130`	`headers.insert(IF_MODIFIED_SINCE, "<nori ate the tag. yum.>");`
`131`	`131`	`let err = IfModifiedSince::from_headers(headers).unwrap_err();`
`132`	`132`	`assert_eq!(err.status(), 400);`
`133`		`- Ok(())`
`134`	`133`	`}`
`135`	`134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,11 +124,10 @@ mod test {`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`#[test]`
`127`		`- fn bad_request_on_parse_error() -> crate::Result<()> {`
	`127`	`+ fn bad_request_on_parse_error() {`
`128`	`128`	`let mut headers = Headers::new();`
`129`	`129`	`headers.insert(LAST_MODIFIED, "<nori ate the tag. yum.>");`
`130`	`130`	`let err = LastModified::from_headers(headers).unwrap_err();`
`131`	`131`	`assert_eq!(err.status(), 400);`
`132`		`- Ok(())`
`133`	`132`	`}`
`134`	`133`	`}`