tests: test that root endpoint and node state

Author: vladimirvolek

src/api/root.rs

@@ -1,9 +1,9 @@
 use crate::{node::sync_progress::SyncProgress, BlockfrostError, NodePool};
 use axum::{response::IntoResponse, Extension, Json};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Serialize)]
-pub struct Response {
+#[derive(Serialize, Deserialize)]
+pub struct RootResponse {
     pub name: String,
     pub version: String,
     pub sync_progress: SyncProgress,
@@ -18,7 +18,7 @@ pub async fn route(
     let mut node = node.get().await?;
     let sync_progress = node.sync_progress().await?;
 
-    let response = Response {
+    let response = RootResponse {
         name: "blockfrost-platform".to_string(),
         version: env!("CARGO_PKG_VERSION").to_string(),
         sync_progress,

src/node/sync_progress.rs

@@ -3,11 +3,12 @@ use crate::BlockfrostError;
 use chrono::{Duration, TimeZone, Utc};
 use pallas_network::{miniprotocols, miniprotocols::localstate};
 use pallas_traverse::wellknown;
+use serde::{Deserialize, Serialize};
 use std::boxed::Box;
 
-#[derive(serde::Serialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct SyncProgress {
-    percentage: f64,
+    pub percentage: f64,
     era: u16,
     epoch: u32,
     slot: u64,

tests/integration_routes_test.rs

@@ -4,12 +4,14 @@ mod tests {
 
     use axum::body::{to_bytes, Body};
     use axum::http::Request;
+    use blockfrost_platform::api::root::RootResponse;
     use blockfrost_platform::{
         cli::{Config, LogLevel, Mode, Network},
         server::build,
     };
     use lazy_static::lazy_static;
-    use serde_json::Value;
+    use pretty_assertions::assert_eq;
+    use reqwest::StatusCode;
     use tower::ServiceExt;
 
     lazy_static! {
@@ -27,12 +29,12 @@ mod tests {
             server_address: "0.0.0.0".into(),
             server_port: 8080,
             log_level: LogLevel::Info.into(),
-            network_magic: 1,
-            mode: Mode::Full,
+            network_magic: 2,
+            mode: Mode::Compact,
             node_socket_path: "/run/cardano-node/node.socket".into(),
             icebreakers_config: None,
             max_pool_connections: 10,
-            network: Network::Preprod,
+            network: Network::Preview,
         }
     }
 
@@ -51,25 +53,29 @@ mod tests {
             .await
             .expect("Failed to send request");
 
-        println!("response:{:?}", response.body());
-
-        // assert_eq!(
-        //     response.status(),
-        //     StatusCode::OK,
-        //     "Root route should return 200"
-        // );
+        // Root route should return 200
+        assert_eq!(
+            response.status(),
+            StatusCode::OK,
+            "Root route should return 200"
+        );
 
         let body_bytes = to_bytes(response.into_body(), usize::MAX)
             .await
             .expect("Failed to read response body");
 
-        let json_body: Value =
-            serde_json::from_slice(&body_bytes).expect("Response body is not valid JSON");
-
-        let body_text = String::from_utf8_lossy(&body_bytes);
+        let root_response: RootResponse = serde_json::from_slice(&body_bytes)
+            .expect("Response body is not valid JSON or doesn't match RootResponse");
 
-        println!("body_text:{:?}", body_text);
+        // Root data
+        assert!(
+            root_response.errors.is_empty(),
+            "Expected no errors in the response"
+        );
+        assert_eq!(root_response.name, "blockfrost-platform");
+        assert!(root_response.healthy);
 
-        assert_eq!(json_body["name"], "blockfrost-platform");
+        // Node should be 100% synced
+        assert_eq!(root_response.sync_progress.percentage, 100.00);
     }
 }