Fix pre-commit hooks

Signed-off-by: Javier G. Sogo <[email protected]>

Author: jgsogo

.github/dependabot.yml

@@ -4,4 +4,4 @@ updates:
     directory: "/"
     # Check for updates every Monday
     schedule:
-      interval: "weekly"
+      interval: "weekly"

src/client/app_configuration_http.rs

@@ -18,8 +18,8 @@ use crate::client::feature_snapshot::FeatureSnapshot;
 pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::{ConfigurationAccessError, Error, Result};
-use crate::TokenProvider;
-use crate::{ServerClientImpl, ServiceAddress};
+use crate::network::{ServiceAddress, TokenProvider};
+use crate::ServerClientImpl;
 use std::net::TcpStream;
 use std::sync::{Arc, Mutex};
 use std::thread;

src/client/app_configuration_ibm_cloud.rs

@@ -17,8 +17,8 @@ use crate::client::feature_snapshot::FeatureSnapshot;
 pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::Result;
+use crate::network::ServiceAddress;
 use crate::IBMCloudTokenProvider;
-use crate::ServiceAddress;
 
 use super::AppConfigurationClientHttp;
 use super::{AppConfigurationClient, ConfigurationId};

src/network/mod.rs

@@ -16,6 +16,6 @@ mod http_client;
 mod token_provider;
 
 pub(crate) use http_client::ServerClientImpl;
-pub use http_client::{ServiceAddress, ServiceAddressProtocol};
+pub use http_client::ServiceAddress;
 pub(crate) use token_provider::IBMCloudTokenProvider;
 pub use token_provider::TokenProvider;

tests/test_initial_configuration_from_server.rs

@@ -4,10 +4,6 @@ use std::{
     thread::{sleep, spawn},
     time::Duration,
 };
-use tungstenite::{
-    accept_hdr, connect,
-    handshake::server::{Request, Response},
-};
 
 use appconfiguration::{
     AppConfigurationClient, AppConfigurationClientHttp, ConfigurationId, ServiceAddress,
@@ -20,23 +16,18 @@ use std::{fs, path::PathBuf};
 use tungstenite::WebSocket;
 
 fn handle_config_request_trivial_config(server: &TcpListener) {
-    let json_payload = r#"
-    {
-    "environments":
-        [
-        {
-        "name": "Dev",
-        "environment_id": "dev",
-        "features": [],
-        "properties": []
-        }
+    let json_payload = serde_json::json!({
+        "environments": [
+            {
+                "name": "Dev",
+                "environment_id": "dev",
+                "features": [],
+                "properties": []
+            }
         ],
-    "segments": []
-    }
-    "#
-    .to_string();
-
-    handle_config_request(server, json_payload);
+        "segments": []
+    });
+    handle_config_request(server, json_payload.to_string());
 }
 
 fn handle_config_request_enterprise_example(server: &TcpListener) {
@@ -67,34 +58,35 @@ fn handle_config_request(server: &TcpListener, json_payload: String) {
 }
 
 fn handle_websocket(server: &TcpListener) -> WebSocket<TcpStream> {
-    let (mut stream, _) = server.accept().unwrap();
+    let (stream, _) = server.accept().unwrap();
     let mut websocket = tungstenite::accept(stream).unwrap();
-    websocket.send(tungstenite::Message::text("test message".to_string())).unwrap();
-    websocket.send(tungstenite::Message::text("test messag".to_string())).unwrap();
+    websocket
+        .send(tungstenite::Message::text("test message".to_string()))
+        .unwrap();
+    websocket
+        .send(tungstenite::Message::text("test messag".to_string()))
+        .unwrap();
     websocket
 }
 
 struct ServerHandle {
-    terminator: std::sync::mpsc::Sender<()>,
+    _terminator: std::sync::mpsc::Sender<()>,
     config_updated: std::sync::mpsc::Receiver<()>,
-    port: u16
+    port: u16,
 }
 fn server_thread() -> ServerHandle {
     let (terminator, receiver) = channel();
     let (config_updated_tx, config_updated_rx) = channel();
 
-    let server = TcpListener::bind(("127.0.0.1", 0))
-        .expect("Failed to bind");
+    let server = TcpListener::bind(("127.0.0.1", 0)).expect("Failed to bind");
     let port = server.local_addr().unwrap().port();
     spawn(move || {
-
         handle_config_request_enterprise_example(&server);
 
         // notify client that config changed
         let _websocket = handle_websocket(&server);
 
-        // client will request changed config
-        // asynchronously
+        // client will request changed config asynchronously
         handle_config_request_trivial_config(&server);
 
         // we now allow the test to continue
@@ -103,9 +95,9 @@ fn server_thread() -> ServerHandle {
         let _ = receiver.recv();
     });
     ServerHandle {
-        terminator,
+        _terminator: terminator,
         config_updated: config_updated_rx,
-        port
+        port,
     }
 }
 
@@ -141,22 +133,19 @@ fn main() {
     features.sort();
     assert_eq!(features, vec!["f1", "f2", "f3", "f4", "f5", "f6"]);
 
+    // TODO: Once we can subscribe to config updates via client APIs, we don't need to wait for signal, neither the loop below
     server.config_updated.recv().unwrap();
 
     let start = std::time::Instant::now();
-
-    loop{
+    loop {
         // We need the loop for now to wait until client updates the config.
-        // TODO: Once we can subscribe to config updates via client APIs, we do not need to loop here anymore.
         let features = client.get_feature_ids().unwrap();
-        if features.is_empty()
-        {
+        if features.is_empty() {
             // This is what we expect after the config update :)
             break;
         }
-        if start.elapsed().as_millis() > 1000
-        {
-            assert!(false, "Did not receive updated configuration in time")
+        if start.elapsed().as_millis() > 1000 {
+            panic!("Did not receive updated configuration in time")
         }
         sleep(Duration::from_millis(10));
     }