cargo fmt

nym-api/tests/public-api/api_status.rs

@@ -17,10 +17,13 @@ async fn test_build_information() {
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
 
-    assert!(json.get("build_version").is_some(), "Expected a value for 'build_version'");
+    assert!(
+        json.get("build_version").is_some(),
+        "Expected a value for 'build_version'"
+    );
 }
 
-// ECASH API TEST 
+// ECASH API TEST
 // #[tokio::test]
 // async fn test_signer_information() {
 //     let url = format!("{}/v1/api-status/signer-information", base_url());
@@ -31,4 +34,4 @@ async fn test_build_information() {
 //     let json: Value = res.json().await.unwrap_or_else(|err| panic!("Invalid JSON response: {}", err));
 
 //     assert!(json.get("signer_address").is_some(), "Expected a value for 'signer_address'");
-// }
+// }

nym-api/tests/public-api/circulating_supply.rs

@@ -1,6 +1,6 @@
 mod utils;
-use utils::{base_url, test_client, validate_json_response};
 use tokio;
+use utils::{base_url, test_client, validate_json_response};
 
 #[tokio::test]
 async fn test_get_circulating_supply() {
@@ -8,16 +8,25 @@ async fn test_get_circulating_supply() {
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
 
-    assert!(json.get("circulating_supply").is_some(), "Expected a value for 'circulating_supply'");
+    assert!(
+        json.get("circulating_supply").is_some(),
+        "Expected a value for 'circulating_supply'"
+    );
 }
 
 #[tokio::test]
 async fn test_get_circulating_supply_value() {
-    let url = format!("{}/v1/circulating-supply/circulating-supply-value", base_url());
+    let url = format!(
+        "{}/v1/circulating-supply/circulating-supply-value",
+        base_url()
+    );
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
 
-    assert!(json.is_number(), "Expected a number for the circulating supply value");
+    assert!(
+        json.is_number(),
+        "Expected a number for the circulating supply value"
+    );
     let number = json.as_f64().unwrap();
     assert!(number >= 0.0, "Circulating supply should not be negative");
 }

nym-api/tests/public-api/contract_cache.rs

@@ -1,6 +1,6 @@
 mod utils;
-use utils::{base_url, test_client, validate_json_response};
 use tokio;
+use utils::{base_url, test_client, validate_json_response};
 
 #[tokio::test]
 async fn test_get_current_epoch() {
@@ -9,8 +9,14 @@ async fn test_get_current_epoch() {
     let json = validate_json_response(res).await;
 
     assert!(json.get("id").is_some(), "Expected a value for 'id'");
-    assert!(json.get("current_epoch_start").is_some(), "Expected a value for `current_epoch_start`");
-    assert!(json.get("total_elapsed_epochs").is_some(), "Expected a value for `total_elapsed_epochs`");
+    assert!(
+        json.get("current_epoch_start").is_some(),
+        "Expected a value for `current_epoch_start`"
+    );
+    assert!(
+        json.get("total_elapsed_epochs").is_some(),
+        "Expected a value for `total_elapsed_epochs`"
+    );
 }
 
 #[tokio::test]
@@ -19,9 +25,19 @@ async fn test_get_reward_params() {
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
 
-    let interval = json.get("interval").expect("Expected a value for 'interval'");
-    assert!(interval.get("reward_pool").is_some(), "Expected a value for 'interval.reward_pool'");
+    let interval = json
+        .get("interval")
+        .expect("Expected a value for 'interval'");
+    assert!(
+        interval.get("reward_pool").is_some(),
+        "Expected a value for 'interval.reward_pool'"
+    );
 
-    let rewarded_set = json.get("rewarded_set").expect("Expected a value for 'rewarded_set'");
-    assert!(rewarded_set.get("exit_gateways").is_some(), "Expected a value for 'rewarded_set.exit_gateways'");
+    let rewarded_set = json
+        .get("rewarded_set")
+        .expect("Expected a value for 'rewarded_set'");
+    assert!(
+        rewarded_set.get("exit_gateways").is_some(),
+        "Expected a value for 'rewarded_set.exit_gateways'"
+    );
 }

nym-api/tests/public-api/network.rs

@@ -1,6 +1,6 @@
 mod utils;
-use utils::{base_url, test_client, validate_json_response};
 use tokio;
+use utils::{base_url, test_client, validate_json_response};
 
 #[tokio::test]
 async fn test_get_chain_status() {
@@ -15,9 +15,14 @@ async fn test_get_chain_status() {
         .and_then(|b| b.get("header"))
         .expect("Expected a value for 'status.block.header'");
 
-    assert!(block_header.get("chain_id").is_some(), "Expected a value for 'chain_id'");
-    assert!(block_header.get("height").is_some(), "Expected a value for 'height'");
-    
+    assert!(
+        block_header.get("chain_id").is_some(),
+        "Expected a value for 'chain_id'"
+    );
+    assert!(
+        block_header.get("height").is_some(),
+        "Expected a value for 'height'"
+    );
 }
 
 #[tokio::test]
@@ -26,12 +31,18 @@ async fn test_get_network_details() {
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
 
-    assert!(json.get("connected_nyxd").is_some(), "Expected a value for 'connected_nyxd'");
+    assert!(
+        json.get("connected_nyxd").is_some(),
+        "Expected a value for 'connected_nyxd'"
+    );
     let contracts = json
-    .get("network")
-    .and_then(|s| s.get("contracts"))
-    .expect("Expected a value for 'contracts'");
-    assert!(contracts.get("mixnet_contract_address").is_some(), "Expected a value for 'mixnet_contract_address'");
+        .get("network")
+        .and_then(|s| s.get("contracts"))
+        .expect("Expected a value for 'contracts'");
+    assert!(
+        contracts.get("mixnet_contract_address").is_some(),
+        "Expected a value for 'mixnet_contract_address'"
+    );
 }
 
 #[tokio::test]
@@ -40,8 +51,14 @@ async fn test_get_nym_contracts() {
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
 
-    assert!(json.get("nym-mixnet-contract").is_some(), "Expected a value for 'nym-mixnet-contract'");
-    assert!(json.get("nym-ecash-contract").is_some(), "Expected a value for 'nym-ecash-contract'");
+    assert!(
+        json.get("nym-mixnet-contract").is_some(),
+        "Expected a value for 'nym-mixnet-contract'"
+    );
+    assert!(
+        json.get("nym-ecash-contract").is_some(),
+        "Expected a value for 'nym-ecash-contract'"
+    );
 }
 
 #[tokio::test]
@@ -51,14 +68,20 @@ async fn test_get_nym_contracts_detailed() {
     let json = validate_json_response(res).await;
 
     let mixnet_contract = json
-    .get("nym-mixnet-contract")
-    .and_then(|s| s.get("details"))
-    .expect("Expected details for the mixnet contract");
-    assert!(mixnet_contract.get("commit_branch").is_some(), "Expected a value for 'commit_branch'");
+        .get("nym-mixnet-contract")
+        .and_then(|s| s.get("details"))
+        .expect("Expected details for the mixnet contract");
+    assert!(
+        mixnet_contract.get("commit_branch").is_some(),
+        "Expected a value for 'commit_branch'"
+    );
 
     let ecash_contract = json
-    .get("nym-ecash-contract")
-    .and_then(|s| s.get("details"))
-    .expect("Expected details for the ecash contract");
-    assert!(ecash_contract.get("commit_branch").is_some(), "Expected a value for 'commit_branch'");
+        .get("nym-ecash-contract")
+        .and_then(|s| s.get("details"))
+        .expect("Expected details for the ecash contract");
+    assert!(
+        ecash_contract.get("commit_branch").is_some(),
+        "Expected a value for 'commit_branch'"
+    );
 }

nym-api/tests/public-api/nym_nodes.rs

@@ -1,7 +1,7 @@
 mod utils;
-use utils::{base_url, test_client, get_any_node_id, validate_json_response};
-use tokio;
 use chrono::Utc;
+use tokio;
+use utils::{base_url, get_any_node_id, test_client, validate_json_response};
 
 #[tokio::test]
 async fn test_get_bonded_nodes() {
@@ -44,9 +44,14 @@ async fn test_get_rewarded_set() {
     let url = format!("{}/v1/nym-nodes/rewarded-set", base_url());
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
-    let exit_gateways = json.get("exit_gateways").expect("Expected a value for 'exit_gateways' field");
+    let exit_gateways = json
+        .get("exit_gateways")
+        .expect("Expected a value for 'exit_gateways' field");
 
-    assert!(exit_gateways.is_array(), "Expected 'exit_gateways' to be an array");
+    assert!(
+        exit_gateways.is_array(),
+        "Expected 'exit_gateways' to be an array"
+    );
     assert!(
         exit_gateways.as_array().unwrap().len() > 0,
         "We have no exit gateways!!"
@@ -60,15 +65,20 @@ async fn test_get_annotation_for_node() {
     let url = format!("{}/v1/nym-nodes/annotation/{}", base_url(), id);
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
-    let annotation = json.get("annotation").expect("Expected a value for 'annotation' field");
+    let annotation = json
+        .get("annotation")
+        .expect("Expected a value for 'annotation' field");
 
-    assert!(annotation.get("last_24h_performance").is_some(), "Expected a value for 'last_24h_performance'");
+    assert!(
+        annotation.get("last_24h_performance").is_some(),
+        "Expected a value for 'last_24h_performance'"
+    );
 }
 #[tokio::test]
 async fn test_get_historical_performance() {
     let id = get_any_node_id().await;
     let date = Utc::now().date_naive().to_string();
-    
+
     let url = format!("{}/v1/nym-nodes/historical-performance/{}", base_url(), id);
     let res = test_client()
         .get(&url)
@@ -78,7 +88,10 @@ async fn test_get_historical_performance() {
         .unwrap();
 
     let json = validate_json_response(res).await;
-    assert!(json.get("performance").is_some(), "Expected a value for 'performance' field");
+    assert!(
+        json.get("performance").is_some(),
+        "Expected a value for 'performance' field"
+    );
 }
 
 #[tokio::test]
@@ -105,8 +118,14 @@ async fn test_get_performance() {
     let url = format!("{}/v1/nym-nodes/performance/{}", base_url(), id);
     let res = test_client().get(&url).send().await.unwrap();
     let json = validate_json_response(res).await;
-    assert!(json.get("node_id").is_some(), "Expected a value for 'node_id'");
-    assert!(json.get("performance").is_some(), "Expected a value for 'performance'");
+    assert!(
+        json.get("node_id").is_some(),
+        "Expected a value for 'node_id'"
+    );
+    assert!(
+        json.get("performance").is_some(),
+        "Expected a value for 'performance'"
+    );
 }
 
 #[tokio::test]
@@ -127,4 +146,4 @@ async fn test_get_uptime_history() {
     );
 }
 
-// TODO add the POST request test for `refresh-described` 
+// TODO add the POST request test for `refresh-described`

nym-api/tests/public-api/status.rs

@@ -1,13 +1,17 @@
 mod utils;
-use utils::{base_url, test_client};
 use serde_json::Value;
 use tokio;
+use utils::{base_url, test_client};
 
 #[tokio::test]
 async fn test_get_config_score_details() {
     let url = format!("{}/v1/status/config-score-details", base_url());
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 200 OK, got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 200 OK, got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
 
@@ -16,7 +20,10 @@ async fn test_get_config_score_details() {
         .and_then(|v| v.as_array())
         .expect("Missing or invalid 'version_history' array");
 
-    assert!(!version_history.is_empty(), "'version_history' should not be empty");
+    assert!(
+        !version_history.is_empty(),
+        "'version_history' should not be empty"
+    );
 
     let max_entry = version_history
         .iter()
@@ -28,9 +35,12 @@ async fn test_get_config_score_details() {
         .and_then(|v| v.get("semver"))
         .and_then(|v| v.as_str());
 
-    assert!(semver.is_some(), "Expected a value for 'semver' in the highest id entry");
+    assert!(
+        semver.is_some(),
+        "Expected a value for 'semver' in the highest id entry"
+    );
 }
 
-// TODO add the POST request tests for: 
+// TODO add the POST request tests for:
 // submit-gateway-monitoring-results
-// submit-node-monitoring-results
+// submit-node-monitoring-results

nym-api/tests/public-api/unstable_nym_nodes.rs

@@ -1,17 +1,23 @@
 mod utils;
-use utils::{base_url, test_client};
 use serde_json::Value;
 use tokio;
-
+use utils::{base_url, test_client};
 
 #[tokio::test]
 async fn test_get_skimmed_nodes_active() {
     let url = format!("{}/v1/unstable/nym-nodes/skimmed/active", base_url());
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let data = json.get("nodes").and_then(|r| r.get("data")).expect("Missing 'data' field");
+    let data = json
+        .get("nodes")
+        .and_then(|r| r.get("data"))
+        .expect("Missing 'data' field");
 
     assert!(data.is_array(), "Expected 'data' to be an array");
     assert!(
@@ -22,80 +28,179 @@ async fn test_get_skimmed_nodes_active() {
 
 #[tokio::test]
 async fn test_get_skimmed_active_mixnodes() {
-    let url = format!("{}/v1/unstable/nym-nodes/skimmed/mixnodes/active", base_url());
+    let url = format!(
+        "{}/v1/unstable/nym-nodes/skimmed/mixnodes/active",
+        base_url()
+    );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let current_epoch_id = json.get("status").and_then(|r| r.get("fresh")).and_then(|r| r.get("current_epoch_id")).expect("Missing 'current_epoch_id'");
+    let current_epoch_id = json
+        .get("status")
+        .and_then(|r| r.get("fresh"))
+        .and_then(|r| r.get("current_epoch_id"))
+        .expect("Missing 'current_epoch_id'");
 
-    assert!(current_epoch_id.is_number(), "Expected 'current_epoch_id' to be an array");
-    assert!(json.get("refreshed_at").is_some(), "Expected a value for 'refreshed_at'");
+    assert!(
+        current_epoch_id.is_number(),
+        "Expected 'current_epoch_id' to be an array"
+    );
+    assert!(
+        json.get("refreshed_at").is_some(),
+        "Expected a value for 'refreshed_at'"
+    );
 }
 
 #[tokio::test]
 async fn test_get_skimmed_all_mixnodes() {
     let url = format!("{}/v1/unstable/nym-nodes/skimmed/mixnodes/all", base_url());
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let current_epoch_id = json.get("status").and_then(|r| r.get("fresh")).and_then(|r| r.get("current_epoch_id")).expect("Expected a value for 'current_epoch_id'");
+    let current_epoch_id = json
+        .get("status")
+        .and_then(|r| r.get("fresh"))
+        .and_then(|r| r.get("current_epoch_id"))
+        .expect("Expected a value for 'current_epoch_id'");
 
-    assert!(current_epoch_id.is_number(), "Expected 'current_epoch_id' to be an array");
-    assert!(json.get("refreshed_at").is_some(), "Expected a value for 'refreshed_at'");
+    assert!(
+        current_epoch_id.is_number(),
+        "Expected 'current_epoch_id' to be an array"
+    );
+    assert!(
+        json.get("refreshed_at").is_some(),
+        "Expected a value for 'refreshed_at'"
+    );
 }
 
 #[tokio::test]
 async fn test_get_skimmed_active_exit_gateways() {
-    let url = format!("{}/v1/unstable/nym-nodes/skimmed/exit-gateways/active", base_url());
+    let url = format!(
+        "{}/v1/unstable/nym-nodes/skimmed/exit-gateways/active",
+        base_url()
+    );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let current_epoch_id = json.get("status").and_then(|r| r.get("fresh")).and_then(|r| r.get("current_epoch_id")).expect("Expected a value for 'current_epoch_id'");
+    let current_epoch_id = json
+        .get("status")
+        .and_then(|r| r.get("fresh"))
+        .and_then(|r| r.get("current_epoch_id"))
+        .expect("Expected a value for 'current_epoch_id'");
 
-    assert!(current_epoch_id.is_number(), "Expected 'current_epoch_id' to be an array");
-    assert!(json.get("refreshed_at").is_some(), "Expected a value for 'refreshed_at'");
+    assert!(
+        current_epoch_id.is_number(),
+        "Expected 'current_epoch_id' to be an array"
+    );
+    assert!(
+        json.get("refreshed_at").is_some(),
+        "Expected a value for 'refreshed_at'"
+    );
 }
 
 #[tokio::test]
 async fn test_get_skimmed_all_exit_gateways() {
-    let url = format!("{}/v1/unstable/nym-nodes/skimmed/exit-gateways/all", base_url());
+    let url = format!(
+        "{}/v1/unstable/nym-nodes/skimmed/exit-gateways/all",
+        base_url()
+    );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let current_epoch_id = json.get("status").and_then(|r| r.get("fresh")).and_then(|r| r.get("current_epoch_id")).expect("Expected a value for 'current_epoch_id'");
+    let current_epoch_id = json
+        .get("status")
+        .and_then(|r| r.get("fresh"))
+        .and_then(|r| r.get("current_epoch_id"))
+        .expect("Expected a value for 'current_epoch_id'");
 
-    assert!(current_epoch_id.is_number(), "Expected 'current_epoch_id' to be an array");
-    assert!(json.get("refreshed_at").is_some(), "Expected a value for 'refreshed_at'");
+    assert!(
+        current_epoch_id.is_number(),
+        "Expected 'current_epoch_id' to be an array"
+    );
+    assert!(
+        json.get("refreshed_at").is_some(),
+        "Expected a value for 'refreshed_at'"
+    );
 }
 
 #[tokio::test]
 async fn test_get_skimmed_active_entry_gateways() {
-    let url = format!("{}/v1/unstable/nym-nodes/skimmed/entry-gateways/active", base_url());
+    let url = format!(
+        "{}/v1/unstable/nym-nodes/skimmed/entry-gateways/active",
+        base_url()
+    );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let current_epoch_id = json.get("status").and_then(|r| r.get("fresh")).and_then(|r| r.get("current_epoch_id")).expect("Expected a value for 'current_epoch_id'");
+    let current_epoch_id = json
+        .get("status")
+        .and_then(|r| r.get("fresh"))
+        .and_then(|r| r.get("current_epoch_id"))
+        .expect("Expected a value for 'current_epoch_id'");
 
-    assert!(current_epoch_id.is_number(), "Expected 'current_epoch_id' to be an array");
-    assert!(json.get("refreshed_at").is_some(), "Expected a value for 'refreshed_at'");
+    assert!(
+        current_epoch_id.is_number(),
+        "Expected 'current_epoch_id' to be an array"
+    );
+    assert!(
+        json.get("refreshed_at").is_some(),
+        "Expected a value for 'refreshed_at'"
+    );
 }
 
 #[tokio::test]
 async fn test_get_skimmed_all_entry_gateways() {
-    let url = format!("{}/v1/unstable/nym-nodes/skimmed/entry-gateways/all", base_url());
+    let url = format!(
+        "{}/v1/unstable/nym-nodes/skimmed/entry-gateways/all",
+        base_url()
+    );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
-    let current_epoch_id = json.get("status").and_then(|r| r.get("fresh")).and_then(|r| r.get("current_epoch_id")).expect("Expected a value for 'current_epoch_id'");
+    let current_epoch_id = json
+        .get("status")
+        .and_then(|r| r.get("fresh"))
+        .and_then(|r| r.get("current_epoch_id"))
+        .expect("Expected a value for 'current_epoch_id'");
 
-    assert!(current_epoch_id.is_number(), "Expected 'current_epoch_id' to be an array");
-    assert!(json.get("refreshed_at").is_some(), "Expected a value for 'refreshed_at'");
+    assert!(
+        current_epoch_id.is_number(),
+        "Expected 'current_epoch_id' to be an array"
+    );
+    assert!(
+        json.get("refreshed_at").is_some(),
+        "Expected a value for 'refreshed_at'"
+    );
 }
 
-// Add the remining tests as the endpoints become active
+// Add the remining tests as the endpoints become active

nym-api/tests/public-api/unstable_status.rs

@@ -1,7 +1,7 @@
 mod utils;
-use utils::{base_url, test_client, get_gateway_identity_key, get_mixnode_node_id};
 use serde_json::Value;
 use tokio;
+use utils::{base_url, get_gateway_identity_key, get_mixnode_node_id, test_client};
 
 #[tokio::test]
 async fn test_get_gateway_unstable_test_results() {
@@ -12,9 +12,16 @@ async fn test_get_gateway_unstable_test_results() {
         identity
     );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
-    let json: Value = res.json().await.unwrap_or_else(|err| panic!("Invalid JSON response: {}", err));
+    let json: Value = res
+        .json()
+        .await
+        .unwrap_or_else(|err| panic!("Invalid JSON response: {}", err));
     let data_array = json
         .get("data")
         .and_then(|v| v.as_array())
@@ -27,12 +34,16 @@ async fn test_get_gateway_unstable_test_results() {
         .and_then(|r| r.get("gateway"))
         .expect("Expected a value for 'test_routes.gateway'");
 
-    assert!(gateway.get("node_id").is_some(), "Expected a value for 'node_id' in gateway");
-    assert!(gateway.get("identity_key").is_some(), "Expected a value for 'identity_key' in gateway");
+    assert!(
+        gateway.get("node_id").is_some(),
+        "Expected a value for 'node_id' in gateway"
+    );
+    assert!(
+        gateway.get("identity_key").is_some(),
+        "Expected a value for 'identity_key' in gateway"
+    );
 }
 
-
-
 #[tokio::test]
 async fn test_get_mixnode_unstable_test_results() {
     let mix_id = get_mixnode_node_id().await;
@@ -42,9 +53,16 @@ async fn test_get_mixnode_unstable_test_results() {
         mix_id
     );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
-    let json: Value = res.json().await.unwrap_or_else(|err| panic!("Invalid JSON response: {}", err));
+    let json: Value = res
+        .json()
+        .await
+        .unwrap_or_else(|err| panic!("Invalid JSON response: {}", err));
     let data_array = json
         .get("data")
         .and_then(|v| v.as_array())
@@ -57,8 +75,14 @@ async fn test_get_mixnode_unstable_test_results() {
         .and_then(|r| r.get("layer3"))
         .expect("Expected a value for 'test_routes.layer3'");
 
-    assert!(layer3.get("node_id").is_some(), "Expected a value for 'node_id' in layer3");
-    assert!(layer3.get("identity_key").is_some(), "Expected a value for 'identity_key' in layer3");
+    assert!(
+        layer3.get("node_id").is_some(),
+        "Expected a value for 'node_id' in layer3"
+    );
+    assert!(
+        layer3.get("identity_key").is_some(),
+        "Expected a value for 'identity_key' in layer3"
+    );
 }
 
 #[tokio::test]
@@ -68,7 +92,11 @@ async fn test_get_latest_network_monitor_run_details() {
         base_url()
     );
     let res = test_client().get(&url).send().await.unwrap();
-    assert!(res.status().is_success(), "Expected 2xx but got {}", res.status());
+    assert!(
+        res.status().is_success(),
+        "Expected 2xx but got {}",
+        res.status()
+    );
 
     let json: Value = res.json().await.unwrap();
     let monitor_run_id = json

nym-api/tests/public-api/utils.rs

@@ -1,7 +1,7 @@
-use reqwest::Client;
-use serde_json::Value;
-use reqwest::Response;
 use dotenv::dotenv;
+use reqwest::Client;
+use reqwest::Response;
+use serde_json::Value;
 
 pub fn test_client() -> Client {
     Client::new()
@@ -11,9 +11,10 @@ pub fn base_url() -> String {
     dotenv().ok();
 
     std::env::var("NYM_API").unwrap_or_else(|err| {
-        std::env::var("NYM_API").unwrap_or_else(|_| panic!("Couldn't find NYM_API env var"))
-        .trim_end_matches('/')
-        .to_string()
+        std::env::var("NYM_API")
+            .unwrap_or_else(|_| panic!("Couldn't find NYM_API env var"))
+            .trim_end_matches('/')
+            .to_string()
     })
 }