Reenable test for plain event json data

daqbufp2/src/test/api4.rs

@@ -1 +1,2 @@
+pub mod binnedjson;
 pub mod eventsjson;

daqbufp2/src/test/api4/binnedjson.rs

@@ -0,0 +1,81 @@
+use crate::err::ErrConv;
+use crate::nodes::require_test_hosts_running;
+use chrono::{DateTime, Utc};
+use err::Error;
+use http::StatusCode;
+use hyper::Body;
+use netpod::query::BinnedQuery;
+use netpod::APP_JSON;
+use netpod::{log::*, AggKind};
+use netpod::{AppendToUrl, Channel, Cluster, HostPort, NanoRange};
+use serde_json::Value as JsonValue;
+use url::Url;
+
+#[test]
+fn binned_d0_json_00() -> Result<(), Error> {
+    let fut = async {
+        let rh = require_test_hosts_running()?;
+        let cluster = &rh.cluster;
+        let jsv = binned_d0_json(
+            Channel {
+                backend: "test-disk-databuffer".into(),
+                name: "scalar-i32-be".into(),
+                series: None,
+            },
+            "1970-01-01T00:20:04.000Z",
+            "1970-01-01T00:20:37.000Z",
+            6,
+            cluster,
+        )
+        .await?;
+        info!("Receveided a response json value: {jsv:?}");
+        let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv)?;
+        // inmem was meant just for functional test, ignores the requested time range
+        assert_eq!(res.len(), 20);
+        assert_eq!(res.ts_anchor_sec(), 0);
+        Ok(())
+    };
+    taskrun::run(fut)
+}
+
+async fn binned_d0_json(
+    channel: Channel,
+    beg_date: &str,
+    end_date: &str,
+    bin_count: u32,
+    cluster: &Cluster,
+) -> Result<JsonValue, Error> {
+    let t1 = Utc::now();
+    let node0 = &cluster.nodes[0];
+    let beg_date: DateTime<Utc> = beg_date.parse()?;
+    let end_date: DateTime<Utc> = end_date.parse()?;
+    let range = NanoRange::from_date_time(beg_date, end_date);
+    let query = BinnedQuery::new(channel, range, bin_count, AggKind::TimeWeightedScalar);
+    let hp = HostPort::from_node(node0);
+    let mut url = Url::parse(&format!("http://{}:{}/api/4/binned", hp.host, hp.port))?;
+    query.append_to_url(&mut url);
+    let url = url;
+    info!("http get {}", url);
+    let req = hyper::Request::builder()
+        .method(http::Method::GET)
+        .uri(url.to_string())
+        .header(http::header::ACCEPT, APP_JSON)
+        .body(Body::empty())
+        .ec()?;
+    let client = hyper::Client::new();
+    let res = client.request(req).await.ec()?;
+    if res.status() != StatusCode::OK {
+        error!("client response {:?}", res);
+        return Err(Error::with_msg_no_trace(format!("bad result {res:?}")));
+    }
+    let buf = hyper::body::to_bytes(res.into_body()).await.ec()?;
+    let s = String::from_utf8_lossy(&buf);
+    let res: JsonValue = serde_json::from_str(&s)?;
+    let pretty = serde_json::to_string_pretty(&res)?;
+    trace!("{pretty}");
+    let t2 = chrono::Utc::now();
+    let ms = t2.signed_duration_since(t1).num_milliseconds() as u64;
+    // TODO add timeout
+    debug!("time {} ms", ms);
+    Ok(res)
+}

daqbufp2/src/test/api4/eventsjson.rs

@@ -17,7 +17,7 @@ fn events_plain_json_00() -> Result<(), Error> {
     let fut = async {
         let rh = require_test_hosts_running()?;
         let cluster = &rh.cluster;
-        events_plain_json(
+        let jsv = events_plain_json(
             Channel {
                 backend: "test-inmem".into(),
                 name: "inmem-d0-i32".into(),
@@ -26,10 +26,13 @@ fn events_plain_json_00() -> Result<(), Error> {
             "1970-01-01T00:20:04.000Z",
             "1970-01-01T00:20:10.000Z",
             cluster,
-            true,
-            4,
         )
         .await?;
+        info!("Receveided a response json value: {jsv:?}");
+        let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv)?;
+        // inmem was meant just for functional test, ignores the requested time range
+        assert_eq!(res.len(), 20);
+        assert_eq!(res.ts_anchor_sec(), 0);
         Ok(())
     };
     taskrun::run(fut)
@@ -49,11 +52,10 @@ fn events_plain_json_01() -> Result<(), Error> {
             "1970-01-01T00:20:10.000Z",
             "1970-01-01T00:20:13.000Z",
             cluster,
-            true,
-            4,
         )
         .await?;
-        let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv).unwrap();
+        info!("Receveided a response json value: {jsv:?}");
+        let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv)?;
         assert_eq!(res.ts_anchor_sec(), 1210);
         assert_eq!(res.pulse_anchor(), 2420);
         let exp = [2420., 2421., 2422., 2423., 2424., 2425.];
@@ -79,8 +81,6 @@ fn events_plain_json_02_range_incomplete() -> Result<(), Error> {
             "1970-01-03T23:59:55.000Z",
             "1970-01-04T00:00:01.000Z",
             cluster,
-            true,
-            4,
         )
         .await?;
         let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv).unwrap();
@@ -97,8 +97,6 @@ async fn events_plain_json(
     beg_date: &str,
     end_date: &str,
     cluster: &Cluster,
-    _expect_range_complete: bool,
-    _expect_event_count: u64,
 ) -> Result<JsonValue, Error> {
     let t1 = Utc::now();
     let node0 = &cluster.nodes[0];
@@ -110,7 +108,7 @@ async fn events_plain_json(
     let mut url = Url::parse(&format!("http://{}:{}/api/4/events", hp.host, hp.port))?;
     query.append_to_url(&mut url);
     let url = url;
-    info!("get_plain_events  get {}", url);
+    info!("http get {}", url);
     let req = hyper::Request::builder()
         .method(http::Method::GET)
         .uri(url.to_string())
@@ -127,9 +125,7 @@ async fn events_plain_json(
     let s = String::from_utf8_lossy(&buf);
     let res: JsonValue = serde_json::from_str(&s)?;
     let pretty = serde_json::to_string_pretty(&res)?;
-    eprintln!("{pretty}");
-
-    // TODO assert more
+    trace!("{pretty}");
     let t2 = chrono::Utc::now();
     let ms = t2.signed_duration_since(t1).num_milliseconds() as u64;
     // TODO add timeout