clippy fixes

Author: keelerm84

contract-tests/src/bin/sse-test-api/stream_entity.rs

@@ -47,7 +47,7 @@ impl Inner {
                 Ok(None) => break,
                 Err(e) => {
                     let failure = EventType::Error {
-                        error: format!("Error: {:?}", e),
+                        error: format!("Error: {e:?}"),
                     };
 
                     if !self.send_message(failure, &client).await {
@@ -62,7 +62,7 @@ impl Inner {
         let json = match serde_json::to_string(&event_type) {
             Ok(s) => s,
             Err(e) => {
-                error!("Failed to json encode event type {:?}", e);
+                error!("Failed to json encode event type {e:?}");
                 return false;
             }
         };
@@ -73,7 +73,7 @@ impl Inner {
 
         match client
             .post(format!("{}/{}", self.callback_url, counter_val))
-            .body(format!("{}\n", json))
+            .body(format!("{json}\n"))
             .send()
             .await
         {
@@ -82,7 +82,7 @@ impl Inner {
                 *counter = counter_val + 1
             }
             Err(e) => {
-                error!("Failed to send post back to test harness {:?}", e);
+                error!("Failed to send post back to test harness {e:?}");
                 return false;
             }
         };
@@ -93,7 +93,7 @@ impl Inner {
     fn build_client(config: &Config) -> Result<Box<dyn es::Client>, String> {
         let mut client_builder = match es::ClientBuilder::for_url(&config.stream_url) {
             Ok(cb) => cb,
-            Err(e) => return Err(format!("Failed to create client builder {:?}", e)),
+            Err(e) => return Err(format!("Failed to create client builder {e:?}")),
         };
 
         let mut reconnect_options = es::ReconnectOptions::reconnect(true);
@@ -122,7 +122,7 @@ impl Inner {
             for (name, value) in headers {
                 client_builder = match client_builder.header(name, value) {
                     Ok(cb) => cb,
-                    Err(e) => return Err(format!("Unable to set header {:?}", e)),
+                    Err(e) => return Err(format!("Unable to set header {e:?}")),
                 };
             }
         }

eventsource-client/examples/tail.rs

@@ -47,8 +47,8 @@ fn tail_events(client: impl es::Client) -> impl Stream<Item = Result<(), ()>> {
                 println!("got an event: {}\n{}", ev.event_type, ev.data)
             }
             es::SSE::Comment(comment) => {
-                println!("got a comment: \n{}", comment)
+                println!("got a comment: \n{comment}")
             }
         })
-        .map_err(|err| eprintln!("error streaming events: {:?}", err))
+        .map_err(|err| eprintln!("error streaming events: {err:?}"))
 }

eventsource-client/src/client.rs

@@ -141,9 +141,9 @@ impl ClientBuilder {
 
     /// Set the Authorization header with the calculated basic authentication value.
     pub fn basic_auth(self, username: &str, password: &str) -> Result<ClientBuilder> {
-        let auth = format!("{}:{}", username, password);
+        let auth = format!("{username}:{password}");
         let encoded = BASE64_STANDARD.encode(auth);
-        let value = format!("Basic {}", encoded);
+        let value = format!("Basic {encoded}");
 
         self.header("Authorization", &value)
     }
@@ -477,7 +477,7 @@ where
                 }
                 StateProj::Connecting { retry, resp } => match ready!(resp.poll(cx)) {
                     Ok(resp) => {
-                        debug!("HTTP response: {:#?}", resp);
+                        debug!("HTTP response: {resp:#?}");
 
                         if resp.status().is_success() {
                             self.as_mut().project().retry_strategy.reset(Instant::now());
@@ -544,7 +544,7 @@ where
                     }
                     Err(e) => {
                         // This happens when the server is unreachable, e.g. connection refused.
-                        warn!("request returned an error: {}", e);
+                        warn!("request returned an error: {e}");
                         if !*retry {
                             self.as_mut().project().state.set(State::StreamClosed);
                             return Poll::Ready(Some(Err(Error::HttpStream(Box::new(e)))));
@@ -645,7 +645,7 @@ fn uri_from_header(maybe_header: &Option<HeaderValue>) -> Result<Uri> {
 }
 
 fn delay(dur: Duration, description: &str) -> Sleep {
-    info!("Waiting {:?} before {}", dur, description);
+    info!("Waiting {dur:?} before {description}");
     tokio::time::sleep(dur)
 }
 
@@ -679,7 +679,7 @@ mod tests {
             .expect("failed to add authentication");
 
         let actual = builder.headers.get("Authorization");
-        let expected = HeaderValue::from_str(format!("Basic {}", expected).as_str())
+        let expected = HeaderValue::from_str(format!("Basic {expected}").as_str())
             .expect("unable to create expected header");
 
         assert_eq!(Some(&expected), actual);
@@ -697,7 +697,7 @@ mod tests {
         ReconnectOptionsBuilder, ReconnectingRequest,
     };
 
-    const INVALID_URI: &'static str = "http://mycrazyunexsistenturl.invaliddomainext";
+    const INVALID_URI: &str = "http://mycrazyunexsistenturl.invaliddomainext";
 
     #[test_case(INVALID_URI, false, |state| matches!(state, State::StreamClosed))]
     #[test_case(INVALID_URI, true, |state| matches!(state, State::WaitingToReconnect(_)))]

eventsource-client/src/event_parser.rs

@@ -186,7 +186,7 @@ impl EventParser {
     }
 
     pub fn process_bytes(&mut self, bytes: Bytes) -> Result<()> {
-        trace!("Parsing bytes {:?}", bytes);
+        trace!("Parsing bytes {bytes:?}");
         // We get bytes from the underlying stream in chunks.  Decoding a chunk has two phases:
         // decode the chunk into lines, and decode the lines into events.
         //
@@ -255,7 +255,7 @@ impl EventParser {
                             Ok(retry) => {
                                 event_data.retry = Some(retry);
                             }
-                            _ => debug!("Failed to parse {:?} into retry value", value),
+                            _ => debug!("Failed to parse {value:?} into retry value"),
                         };
                     }
                 }
@@ -424,7 +424,7 @@ mod tests {
 
         match parse_field(b"\x80: invalid UTF-8") {
             Err(InvalidLine(msg)) => assert!(msg.contains("Utf8Error")),
-            res => panic!("expected InvalidLine error, got {:?}", res),
+            res => panic!("expected InvalidLine error, got {res:?}"),
         }
     }
 
@@ -719,8 +719,8 @@ mod tests {
     }
 
     fn read_contents_from_file(name: &str) -> Vec<u8> {
-        std::fs::read(format!("test-data/{}", name))
-            .unwrap_or_else(|_| panic!("couldn't read {}", name))
+        std::fs::read(format!("test-data/{name}"))
+            .unwrap_or_else(|_| panic!("couldn't read {name}"))
     }
 
     proptest! {