Adapt tests to ST data

archapp/src/archeng/blockstream.rs

@@ -454,6 +454,7 @@ mod test {
     use super::*;
     use crate::archeng::blockrefstream::blockref_stream;
     use crate::archeng::indexfiles::index_file_path_list;
+    use chrono::{DateTime, Utc};
     use futures_util::StreamExt;
     use items::{LogItem, RangeCompletableItem, StreamItem};
     use netpod::{timeunits::SEC, Channel, Database};
@@ -482,7 +483,8 @@ mod test {
     async fn count_events(range: NanoRange, expand: bool, collect_ts: bool) -> Result<EventCount, Error> {
         let channel = Channel {
             backend: "sls-archive".into(),
-            name: "X05DA-FE-WI1:TC1".into(),
+            //name: "X05DA-FE-WI1:TC1".into(),
+            name: "ARIDI-PCT:CURRENT".into(),
         };
         let dbconf = Database {
             host: "localhost".into(),
@@ -516,6 +518,7 @@ mod test {
                             let n = item.len();
                             for i in 0..n {
                                 let ts = item.ts(i);
+                                //info!("See event {}", ts);
                                 if ts < range.beg {
                                     ret.pre += 1;
                                 } else if ts < range.end {
@@ -540,135 +543,149 @@ mod test {
         Ok(ret)
     }
 
+    fn tons(dt: &DateTime<Utc>) -> u64 {
+        dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
+    }
+
+    /*
+    See event 1636498894380250805
+    See event 1636499776028981476
+
+    See event 1636413555754299959
+    See event 1636413555908344145
+    See event 1636498896546533901
+    See event 1636498896546540966
+    See event 1636499855546054375
+    See event 1636499914581647548
+    See event 1636537592102377806
+    See event 1636545517217768432
+    See event 1636560318439777562
+    See event 1636585292173222036
+    See event 1636585292173229436
+    */
+
     #[test]
-    fn read_blocks_one_event() -> Result<(), Error> {
+    fn read_blocks_one_event_basic() -> Result<(), Error> {
+        //let ta = "2021-11-09T10:00:00Z";
+        //let tb = "2021-11-09T11:00:00Z";
         let _ev1 = "2021-10-03T09:57:59.939651334Z";
         let _ev2 = "2021-10-03T09:58:59.940910313Z";
         let _ev3 = "2021-10-03T09:59:59.940112431Z";
-        let ev1ts = 1633255079939651334;
+        // This is from bl SH index:
-        let ev2ts = 1633255139940910313;
+        //let ev1ts = 1633255079939651334;
+        //let ev2ts = 1633255139940910313;
         // [ev1..ev2]
-        let range = NanoRange { beg: ev1ts, end: ev2ts };
+        //let beg = tons(&ta.parse()?);
+        //let end = tons(&tb.parse()?);
+        //let ev1ts = 1636498896546533901;
+        //let ev2ts = 1636498896546540966;
+
+        let beg = 1636455492985809049;
+        let end = 1636455493306756248;
+        let range = NanoRange { beg, end };
         let res = taskrun::run(count_events(range, false, true))?;
         assert_eq!(res.pre, 0);
         assert_eq!(res.inside, 1);
         assert_eq!(res.post, 0);
-        assert_eq!(res.tss[0], ev1ts);
+        assert_eq!(res.tss[0], beg);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
     fn read_blocks_one_event_expand() -> Result<(), Error> {
-        let ev1ts = 1633255079939651334;
+        // This is from bl SH index:
-        let ev2ts = 1633255139940910313;
+        //let ev1ts = 1633255079939651334;
-        let range = NanoRange { beg: ev1ts, end: ev2ts };
+        //let ev2ts = 1633255139940910313;
+        let beg = 1636455492985809049;
+        let end = 1636455493306756248;
+        let range = NanoRange { beg, end };
         let res = taskrun::run(count_events(range, true, true))?;
         assert_eq!(res.pre, 1);
         assert_eq!(res.inside, 1);
         assert_eq!(res.post, 1);
-        assert_eq!(res.tss[1], ev1ts);
+        assert_eq!(res.tss[1], beg);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
-    fn read_blocks_two_events() -> Result<(), Error> {
+    fn read_blocks_two_events_basic() -> Result<(), Error> {
-        let ev1ts = 1633255079939651334;
+        let beg = 1636455492985809049;
-        let ev2ts = 1633255139940910313;
+        let end = 1636455493306756248;
-        let range = NanoRange {
+        let range = NanoRange { beg: beg, end: end + 1 };
-            beg: ev1ts,
-            end: ev2ts + 1,
-        };
         let res = taskrun::run(count_events(range, false, true))?;
         assert_eq!(res.pre, 0);
         assert_eq!(res.inside, 2);
         assert_eq!(res.post, 0);
-        assert_eq!(res.tss[0], ev1ts);
+        assert_eq!(res.tss[0], beg);
-        assert_eq!(res.tss[1], ev2ts);
+        assert_eq!(res.tss[1], end);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
     fn read_blocks_two_events_expand() -> Result<(), Error> {
-        let ev1ts = 1633255079939651334;
+        let beg = 1636455492985809049;
-        let ev2ts = 1633255139940910313;
+        let end = 1636455493306756248;
-        let range = NanoRange {
+        let range = NanoRange { beg: beg, end: end + 1 };
-            beg: ev1ts,
-            end: ev2ts + 1,
-        };
         let res = taskrun::run(count_events(range, true, true))?;
         assert_eq!(res.pre, 1);
         assert_eq!(res.inside, 2);
         assert_eq!(res.post, 1);
-        assert_eq!(res.tss[1], ev1ts);
+        assert_eq!(res.tss[1], beg);
-        assert_eq!(res.tss[2], ev2ts);
+        assert_eq!(res.tss[2], end);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
-    fn read_blocks_many_1() -> Result<(), Error> {
+    fn read_blocks_many_1_basic() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2021-11-09T10:00:00Z";
-        let _early = "2021-10-06T00:00:00Z";
+        let dtend = "2021-11-09T11:00:00Z";
-        let _late = "2021-10-07T00:00:00Z";
+        let dtbeg: DateTime<Utc> = dtbeg.parse()?;
-        let dtbeg: DateTime<Utc> = _early.parse()?;
+        let dtend: DateTime<Utc> = dtend.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
             beg: tons(&dtbeg),
             end: tons(&dtend),
         };
         let res = taskrun::run(count_events(range, false, false))?;
         assert_eq!(res.pre, 0);
-        assert_eq!(res.inside, 77);
+        assert_eq!(res.inside, 726);
         assert_eq!(res.post, 0);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
-    fn read_blocks_many_2() -> Result<(), Error> {
+    fn read_blocks_many_1_expand() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2021-11-09T10:00:00Z";
-        let _early = "2021-09-01T00:00:00Z";
+        let dtend = "2021-11-09T11:00:00Z";
-        let _late = "2021-10-07T00:00:00Z";
+        let dtbeg: DateTime<Utc> = dtbeg.parse()?;
-        let dtbeg: DateTime<Utc> = _early.parse()?;
+        let dtend: DateTime<Utc> = dtend.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
             beg: tons(&dtbeg),
             end: tons(&dtend),
         };
-        let res = taskrun::run(count_events(range, false, false))?;
+        let res = taskrun::run(count_events(range, true, false))?;
-        assert_eq!(res.pre, 0);
+        assert_eq!(res.pre, 1);
-        assert_eq!(res.inside, 20328);
+        assert_eq!(res.inside, 726);
-        assert_eq!(res.post, 0);
+        assert_eq!(res.post, 1);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
-    fn read_blocks_many_3() -> Result<(), Error> {
+    fn read_blocks_many_3_basic() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2021-11-09T10:00:00Z";
-        let _early = "2021-08-01T00:00:00Z";
+        let dtend = "2021-11-09T13:00:00Z";
-        let _late = "2021-10-07T00:00:00Z";
-        let dtbeg: DateTime<Utc> = _early.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
-            beg: tons(&dtbeg),
+            beg: tons(&dtbeg.parse()?),
-            end: tons(&dtend),
+            end: tons(&dtend.parse()?),
         };
         let res = taskrun::run(count_events(range, false, false))?;
         assert_eq!(res.pre, 0);
-        assert_eq!(res.inside, 35438);
+        assert_eq!(res.inside, 2089);
         assert_eq!(res.post, 0);
         assert_eq!(res.raco, 1);
         Ok(())
@@ -676,43 +693,31 @@ mod test {
 
     #[test]
     fn read_blocks_many_3_expand() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2021-11-09T10:00:00Z";
-        let _early = "2021-08-01T00:00:00Z";
+        let dtend = "2021-11-09T13:00:00Z";
-        let _late = "2021-10-07T00:00:00Z";
-        let dtbeg: DateTime<Utc> = _early.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
-            beg: tons(&dtbeg),
+            beg: tons(&dtbeg.parse()?),
-            end: tons(&dtend),
+            end: tons(&dtend.parse()?),
         };
         let res = taskrun::run(count_events(range, true, false))?;
         assert_eq!(res.pre, 1);
-        assert_eq!(res.inside, 35438);
+        assert_eq!(res.inside, 2089);
         assert_eq!(res.post, 1);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
-    fn read_blocks_many_4() -> Result<(), Error> {
+    fn read_blocks_many_4_basic() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2020-11-09T10:00:00Z";
-        let _early = "2020-01-01T00:00:00Z";
+        let dtend = "2021-11-09T13:00:00Z";
-        let _late = "2021-10-07T00:00:00Z";
-        let dtbeg: DateTime<Utc> = _early.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
-            beg: tons(&dtbeg),
+            beg: tons(&dtbeg.parse()?),
-            end: tons(&dtend),
+            end: tons(&dtend.parse()?),
         };
         let res = taskrun::run(count_events(range, false, false))?;
         assert_eq!(res.pre, 0);
-        assert_eq!(res.inside, 71146);
+        assert_eq!(res.inside, 9518);
         assert_eq!(res.post, 0);
         assert_eq!(res.raco, 1);
         Ok(())
@@ -720,43 +725,31 @@ mod test {
 
     #[test]
     fn read_blocks_many_4_expand() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2020-11-09T10:00:00Z";
-        let _early = "2020-01-01T00:00:00Z";
+        let dtend = "2021-11-09T13:00:00Z";
-        let _late = "2021-10-07T00:00:00Z";
-        let dtbeg: DateTime<Utc> = _early.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
-            beg: tons(&dtbeg),
+            beg: tons(&dtbeg.parse()?),
-            end: tons(&dtend),
+            end: tons(&dtend.parse()?),
         };
         let res = taskrun::run(count_events(range, true, false))?;
         assert_eq!(res.pre, 0);
-        assert_eq!(res.inside, 71146);
+        assert_eq!(res.inside, 9518);
         assert_eq!(res.post, 1);
         assert_eq!(res.raco, 1);
         Ok(())
     }
 
     #[test]
-    fn read_blocks_late() -> Result<(), Error> {
+    fn read_blocks_late_basic() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2021-11-09T10:00:00Z";
-        let _early = "2021-10-01T00:00:00Z";
+        let dtend = "2022-11-09T13:00:00Z";
-        let _late = "2021-12-01T00:00:00Z";
-        let dtbeg: DateTime<Utc> = _early.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
-            beg: tons(&dtbeg),
+            beg: tons(&dtbeg.parse()?),
-            end: tons(&dtend),
+            end: tons(&dtend.parse()?),
         };
         let res = taskrun::run(count_events(range, false, false))?;
         assert_eq!(res.pre, 0);
-        assert_eq!(res.inside, 3000);
+        assert_eq!(res.inside, 12689);
         assert_eq!(res.post, 0);
         assert_eq!(res.raco, 0);
         Ok(())
@@ -764,21 +757,15 @@ mod test {
 
     #[test]
     fn read_blocks_late_expand() -> Result<(), Error> {
-        use chrono::{DateTime, Utc};
+        let dtbeg = "2021-11-09T10:00:00Z";
-        let _early = "2021-10-01T00:00:00Z";
+        let dtend = "2022-11-09T13:00:00Z";
-        let _late = "2021-12-01T00:00:00Z";
-        let dtbeg: DateTime<Utc> = _early.parse()?;
-        let dtend: DateTime<Utc> = _late.parse()?;
-        fn tons(dt: &DateTime<Utc>) -> u64 {
-            dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64
-        }
         let range = NanoRange {
-            beg: tons(&dtbeg),
+            beg: tons(&dtbeg.parse()?),
-            end: tons(&dtend),
+            end: tons(&dtend.parse()?),
         };
         let res = taskrun::run(count_events(range, true, false))?;
         assert_eq!(res.pre, 1);
-        assert_eq!(res.inside, 3000);
+        assert_eq!(res.inside, 12689);
         assert_eq!(res.post, 0);
         assert_eq!(res.raco, 0);
         Ok(())

daqbufp2/src/test/binnedjson.rs

@@ -74,6 +74,20 @@ async fn get_binned_json_2_inner() -> Result<(), Error> {
     .await
 }
 
+fn check_close(a: &BinnedResponse, b: &BinnedResponse, jsstr: &String) -> Result<(), Error> {
+    match a.is_close(b) {
+        Ok(true) => Ok(()),
+        Ok(false) => {
+            error!("Mismatch, original JSON:\n{}", jsstr);
+            Err(Error::with_msg_no_trace("mismatch"))
+        }
+        Err(e) => {
+            error!("Mismatch, original JSON:\n{}", jsstr);
+            Err(e)
+        }
+    }
+}
+
 #[test]
 fn get_sls_archive_1() -> Result<(), Error> {
     let fut = async move {
@@ -85,10 +99,11 @@ fn get_sls_archive_1() -> Result<(), Error> {
         };
         let begstr = "2021-11-10T01:00:00Z";
         let endstr = "2021-11-10T01:01:00Z";
-        let res = get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
+        let (res, jsstr) =
+            get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
         let exp = r##"{"avgs":[24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875],"counts":[0,0,0,0,0,0,0,0,0,0,0,0],"finalisedRange":true,"maxs":[24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875],"mins":[24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875,24.37225341796875],"tsAnchor":1636506000,"tsMs":[0,5000,10000,15000,20000,25000,30000,35000,40000,45000,50000,55000,60000],"tsNs":[0,0,0,0,0,0,0,0,0,0,0,0,0]}"##;
         let exp: BinnedResponse = serde_json::from_str(exp).unwrap();
-        res.is_close(&exp)?;
+        check_close(&res, &exp, &jsstr)?;
         Ok(())
     };
     taskrun::run(fut)
@@ -105,10 +120,11 @@ fn get_sls_archive_2() -> Result<(), Error> {
         };
         let begstr = "2021-11-10T00:00:00Z";
         let endstr = "2021-11-10T00:10:00Z";
-        let res = get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
+        let (res, jsstr) =
+            get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
         let exp = r##"{"avgs":[401.1745910644531,401.5135498046875,400.8823547363281,400.66156005859375,401.8301086425781,401.19305419921875,400.5584411621094,401.4371337890625,401.4137268066406,400.77880859375],"counts":[19,6,6,19,6,6,6,19,6,6],"finalisedRange":true,"maxs":[402.04977411361034,401.8439029736943,401.22628955394583,402.1298351124666,402.1298351124666,401.5084092642013,400.8869834159359,402.05358654212733,401.74477983225313,401.1271664125047],"mins":[400.08256099885625,401.22628955394583,400.60867613419754,400.0939982844072,401.5084092642013,400.8869834159359,400.2693699961876,400.05968642775446,401.1271664125047,400.50574056423943],"tsAnchor":1636502400,"tsMs":[0,60000,120000,180000,240000,300000,360000,420000,480000,540000,600000],"tsNs":[0,0,0,0,0,0,0,0,0,0,0]}"##;
         let exp: BinnedResponse = serde_json::from_str(exp).unwrap();
-        res.is_close(&exp)?;
+        check_close(&res, &exp, &jsstr)?;
         Ok(())
     };
     taskrun::run(fut)
@@ -125,10 +141,11 @@ fn get_sls_archive_3() -> Result<(), Error> {
         };
         let begstr = "2021-11-09T00:00:00Z";
         let endstr = "2021-11-11T00:10:00Z";
-        let res = get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
+        let (res, jsstr) =
+            get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
         let exp = r##"{"avgs":[401.1354675292969,401.1296081542969,401.1314392089844,401.134765625,401.1371154785156,376.5816345214844,401.13775634765625,209.2684783935547,-0.06278431415557861,-0.06278431415557861,-0.06278431415557861,-0.047479934990406036,0.0],"counts":[2772,2731,2811,2689,2803,2203,2355,1232,0,0,0,2,0],"maxs":[402.1717718261533,402.18702154022117,402.1908339687381,402.198458825772,402.17939668318724,402.194646397255,402.1908339687381,402.1908339687381,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,0.0,0.0],"mins":[400.0291869996188,400.02537457110185,400.0291869996188,400.0329994281358,400.0291869996188,0.0,400.0444367136866,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,0.0],"tsAnchor":1636416000,"tsMs":[0,14400000,28800000,43200000,57600000,72000000,86400000,100800000,115200000,129600000,144000000,158400000,172800000,187200000],"tsNs":[0,0,0,0,0,0,0,0,0,0,0,0,0,0]}"##;
         let exp: BinnedResponse = serde_json::from_str(exp).unwrap();
-        res.is_close(&exp)?;
+        check_close(&res, &exp, &jsstr)?;
         Ok(())
     };
     taskrun::run(fut)
@@ -145,10 +162,11 @@ fn get_sls_archive_wave_1() -> Result<(), Error> {
         };
         let begstr = "2021-11-09T00:00:00Z";
         let endstr = "2021-11-11T00:10:00Z";
-        let res = get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
+        let (res, jsstr) =
+            get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
         let exp = r##"{"avgs":[401.1354675292969,401.1296081542969,401.1314392089844,401.134765625,401.1371154785156,376.5816345214844,401.13775634765625,209.2684783935547,-0.06278431415557861,-0.06278431415557861,-0.06278431415557861,-0.047479934990406036,0.0],"counts":[2772,2731,2811,2689,2803,2203,2355,1232,0,0,0,2,0],"maxs":[402.1717718261533,402.18702154022117,402.1908339687381,402.198458825772,402.17939668318724,402.194646397255,402.1908339687381,402.1908339687381,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,0.0,0.0],"mins":[400.0291869996188,400.02537457110185,400.0291869996188,400.0329994281358,400.0291869996188,0.0,400.0444367136866,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,-0.06278431346925281,0.0],"tsAnchor":1636416000,"tsMs":[0,14400000,28800000,43200000,57600000,72000000,86400000,100800000,115200000,129600000,144000000,158400000,172800000,187200000],"tsNs":[0,0,0,0,0,0,0,0,0,0,0,0,0,0]}"##;
         let exp: BinnedResponse = serde_json::from_str(exp).unwrap();
-        res.is_close(&exp)?;
+        check_close(&res, &exp, &jsstr)?;
         Ok(())
     };
     taskrun::run(fut)
@@ -165,10 +183,11 @@ fn get_sls_archive_wave_2() -> Result<(), Error> {
         };
         let begstr = "2021-11-09T10:00:00Z";
         let endstr = "2021-11-10T06:00:00Z";
-        let res = get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
+        let (res, jsstr) =
-        let exp = r##"{"avgs":[0.00014690558600705117,0.00014207433559931815,0.0001436264137737453,0.00014572929649148136,0.00015340493700932711,0.00014388437557499856,0.00012792187044396996,0.00014416234625969082,0.0001486341789131984,0.000145719779538922],"counts":[209,214,210,219,209,192,171,307,285,232],"maxs":[0.001784245832823217,0.0016909628175199032,0.0017036109929904342,0.0016926786629483104,0.001760474289767444,0.0018568832892924547,0.001740367733873427,0.0017931810580193996,0.0017676990246400237,0.002342566382139921],"mins":[0.000040829672798281536,0.00004028259718324989,0.000037641591916326433,0.000039788486901670694,0.00004028418697998859,0.00003767738598980941,0.0,0.00004095739495824091,0.00004668773908633739,0.00003859612115775235],"tsAnchor":1636452000,"tsMs":[0,7200000,14400000,21600000,28800000,36000000,43200000,50400000,57600000,64800000,72000000],"tsNs":[0,0,0,0,0,0,0,0,0,0,0]}"##;
+            get_binned_json_common_res(channel, begstr, endstr, 10, AggKind::TimeWeightedScalar, cluster).await?;
+        let exp = r##"{"avgs":[2.0403556177939208e-8,1.9732556921780997e-8,1.9948116047885378e-8,2.024017220492169e-8,2.1306243880303555e-8,1.998394871804976e-8,1.776692748478581e-8,2.002254362309941e-8,2.0643645015638867e-8,2.0238848819076338e-8],"counts":[209,214,210,219,209,192,171,307,285,232],"maxs":[0.001784245832823217,0.0016909628175199032,0.0017036109929904342,0.0016926786629483104,0.0017604742897674441,0.0018568832892924547,0.001740367733873427,0.0017931810580193996,0.0017676990246400237,0.002342566382139921],"mins":[0.000040829672798281536,0.00004028259718324989,0.000037641591916326433,0.000039788486901670694,0.00004028418697998859,0.00003767738598980941,0.0,0.00004095739495824091,0.00004668773908633739,0.00003859612115775235],"tsAnchor":1636452000,"tsMs":[0,7200000,14400000,21600000,28800000,36000000,43200000,50400000,57600000,64800000,72000000],"tsNs":[0,0,0,0,0,0,0,0,0,0,0]}"##;
         let exp: BinnedResponse = serde_json::from_str(exp).unwrap();
-        res.is_close(&exp)?;
+        check_close(&res, &exp, &jsstr)?;
         Ok(())
     };
     taskrun::run(fut)
@@ -317,7 +336,7 @@ async fn get_binned_json_common_res(
     bin_count: u32,
     agg_kind: AggKind,
     cluster: &Cluster,
-) -> Result<BinnedResponse, Error> {
+) -> Result<(BinnedResponse, String), Error> {
     let t1 = Utc::now();
     let node0 = &cluster.nodes[0];
     let beg_date: DateTime<Utc> = beg_date.parse()?;
@@ -344,7 +363,6 @@ async fn get_binned_json_common_res(
     let t2 = chrono::Utc::now();
     let _ms = t2.signed_duration_since(t1).num_milliseconds() as u64;
     let res = String::from_utf8_lossy(&res).to_string();
-    info!("GOT: {}", res);
+    let ret: BinnedResponse = serde_json::from_str(res.as_str())?;
-    let res: BinnedResponse = serde_json::from_str(res.as_str())?;
+    Ok((ret, res))
-    Ok(res)
 }