fix: fixed deprecations and ran clippy --fix

aw-client-rust/src/lib.rs

@@ -27,7 +27,7 @@ impl std::fmt::Debug for AwClient {
 
 impl AwClient {
     pub fn new(ip: &str, port: &str, name: &str) -> AwClient {
-        let baseurl = format!("http://{}:{}", ip, port);
+        let baseurl = format!("http://{ip}:{port}");
         let client = reqwest::blocking::Client::builder()
             .timeout(std::time::Duration::from_secs(120))
             .build()
@@ -43,18 +43,18 @@ impl AwClient {
 
     pub fn get_bucket(&self, bucketname: &str) -> Result<Bucket, reqwest::Error> {
         let url = format!("{}/api/0/buckets/{}", self.baseurl, bucketname);
-        let bucket = self.client.get(&url).send()?.error_for_status()?.json()?;
+        let bucket = self.client.get(url).send()?.error_for_status()?.json()?;
         Ok(bucket)
     }
 
     pub fn get_buckets(&self) -> Result<HashMap<String, Bucket>, reqwest::Error> {
         let url = format!("{}/api/0/buckets/", self.baseurl);
-        self.client.get(&url).send()?.json()
+        self.client.get(url).send()?.json()
     }
 
     pub fn create_bucket(&self, bucket: &Bucket) -> Result<(), reqwest::Error> {
         let url = format!("{}/api/0/buckets/{}", self.baseurl, bucket.id);
-        self.client.post(&url).json(bucket).send()?;
+        self.client.post(url).json(bucket).send()?;
         Ok(())
     }
 
@@ -80,7 +80,7 @@ impl AwClient {
 
     pub fn delete_bucket(&self, bucketname: &str) -> Result<(), reqwest::Error> {
         let url = format!("{}/api/0/buckets/{}", self.baseurl, bucketname);
-        self.client.delete(&url).send()?;
+        self.client.delete(url).send()?;
         Ok(())
     }
 
@@ -115,7 +115,7 @@ impl AwClient {
     pub fn insert_event(&self, bucketname: &str, event: &Event) -> Result<(), reqwest::Error> {
         let url = format!("{}/api/0/buckets/{}/events", self.baseurl, bucketname);
         let eventlist = vec![event.clone()];
-        self.client.post(&url).json(&eventlist).send()?;
+        self.client.post(url).json(&eventlist).send()?;
         Ok(())
     }
 
@@ -125,7 +125,7 @@ impl AwClient {
         events: Vec<Event>,
     ) -> Result<(), reqwest::Error> {
         let url = format!("{}/api/0/buckets/{}/events", self.baseurl, bucketname);
-        self.client.post(&url).json(&events).send()?;
+        self.client.post(url).json(&events).send()?;
         Ok(())
     }
 
@@ -139,7 +139,7 @@ impl AwClient {
             "{}/api/0/buckets/{}/heartbeat?pulsetime={}",
             self.baseurl, bucketname, pulsetime
         );
-        self.client.post(&url).json(&event).send()?;
+        self.client.post(url).json(&event).send()?;
         Ok(())
     }
 
@@ -148,22 +148,22 @@ impl AwClient {
             "{}/api/0/buckets/{}/events/{}",
             self.baseurl, bucketname, event_id
         );
-        self.client.delete(&url).send()?;
+        self.client.delete(url).send()?;
         Ok(())
     }
 
     pub fn get_event_count(&self, bucketname: &str) -> Result<i64, reqwest::Error> {
         let url = format!("{}/api/0/buckets/{}/events/count", self.baseurl, bucketname);
-        let res = self.client.get(&url).send()?.error_for_status()?.text()?;
+        let res = self.client.get(url).send()?.error_for_status()?.text()?;
         let count: i64 = match res.trim().parse() {
             Ok(count) => count,
-            Err(err) => panic!("could not parse get_event_count response: {:?}", err),
+            Err(err) => panic!("could not parse get_event_count response: {err:?}"),
         };
         Ok(count)
     }
 
     pub fn get_info(&self) -> Result<aw_models::Info, reqwest::Error> {
         let url = format!("{}/api/0/info", self.baseurl);
-        self.client.get(&url).send()?.json()
+        self.client.get(url).send()?.json()
     }
 }

aw-client-rust/tests/test.rs

@@ -21,15 +21,14 @@ mod test {
     // FIXME: Bind to a port that is free for certain and use that for the client instead
     static PORT: u16 = 41293;
 
-    fn wait_for_server(timeout_s: u32, client: &AwClient) -> () {
+    fn wait_for_server(timeout_s: u32, client: &AwClient) {
         for i in 0.. {
             match client.get_info() {
                 Ok(_) => break,
                 Err(err) => {
                     if i == timeout_s - 1 {
                         panic!(
-                            "Timed out starting aw-server after {}s: {:?}",
-                            timeout_s, err
+                            "Timed out starting aw-server after {timeout_s}s: {err:?}"
                         );
                     }
                 }
@@ -72,20 +71,20 @@ mod test {
         wait_for_server(20, &client);
 
         let info = client.get_info().unwrap();
-        assert!(info.testing == true);
+        assert!(info.testing);
 
         let bucketname = format!("aw-client-rust-test_{}", client.hostname);
         let buckettype = "test-type";
         client
-            .create_bucket_simple(&bucketname, &buckettype)
+            .create_bucket_simple(&bucketname, buckettype)
             .unwrap();
 
         let bucket = client.get_bucket(&bucketname).unwrap();
         assert!(bucket.id == bucketname);
         println!("{}", bucket.id);
 
         let buckets = client.get_buckets().unwrap();
-        println!("Buckets: {:?}", buckets);
+        println!("Buckets: {buckets:?}");
         let mut event = Event {
             id: None,
             timestamp: DateTime::from_utc(
@@ -97,7 +96,7 @@ mod test {
             duration: Duration::seconds(0),
             data: Map::new(),
         };
-        println!("{:?}", event);
+        println!("{event:?}");
         client.insert_event(&bucketname, &event).unwrap();
         // Ugly way to create a UTC from timestamp, see https://github.com/chronotope/chrono/issues/263
         event.timestamp = DateTime::from_utc(
@@ -109,7 +108,7 @@ mod test {
         client.heartbeat(&bucketname, &event, 10.0).unwrap();
 
         let events = client.get_events(&bucketname, None, None, None).unwrap();
-        println!("Events: {:?}", events);
+        println!("Events: {events:?}");
         assert!(events[0].duration == Duration::seconds(1));
 
         client