diff --git a/archapp/src/archeng/blockstream.rs b/archapp/src/archeng/blockstream.rs index 2e7ed52..dadeb87 100644 --- a/archapp/src/archeng/blockstream.rs +++ b/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 { 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) -> 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; - let ev2ts = 1633255139940910313; + // This is from bl SH index: + //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; - let ev2ts = 1633255139940910313; - let range = NanoRange { beg: ev1ts, end: ev2ts }; + // This is from bl SH index: + //let ev1ts = 1633255079939651334; + //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> { - let ev1ts = 1633255079939651334; - let ev2ts = 1633255139940910313; - let range = NanoRange { - beg: ev1ts, - end: ev2ts + 1, - }; + fn read_blocks_two_events_basic() -> Result<(), Error> { + let beg = 1636455492985809049; + let end = 1636455493306756248; + let range = NanoRange { beg: beg, end: end + 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[1], ev2ts); + assert_eq!(res.tss[0], beg); + 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 ev2ts = 1633255139940910313; - let range = NanoRange { - beg: ev1ts, - end: ev2ts + 1, - }; + let beg = 1636455492985809049; + let end = 1636455493306756248; + let range = NanoRange { beg: beg, end: end + 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[2], ev2ts); + assert_eq!(res.tss[1], beg); + assert_eq!(res.tss[2], end); assert_eq!(res.raco, 1); Ok(()) } #[test] - fn read_blocks_many_1() -> Result<(), Error> { - use chrono::{DateTime, Utc}; - let _early = "2021-10-06T00:00:00Z"; - let _late = "2021-10-07T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + fn read_blocks_many_1_basic() -> Result<(), Error> { + let dtbeg = "2021-11-09T10:00:00Z"; + let dtend = "2021-11-09T11:00:00Z"; + let dtbeg: DateTime = dtbeg.parse()?; + let dtend: DateTime = dtend.parse()?; 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> { - use chrono::{DateTime, Utc}; - let _early = "2021-09-01T00:00:00Z"; - let _late = "2021-10-07T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + fn read_blocks_many_1_expand() -> Result<(), Error> { + let dtbeg = "2021-11-09T10:00:00Z"; + let dtend = "2021-11-09T11:00:00Z"; + let dtbeg: DateTime = dtbeg.parse()?; + let dtend: DateTime = dtend.parse()?; 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, 20328); - assert_eq!(res.post, 0); + let res = taskrun::run(count_events(range, true, false))?; + assert_eq!(res.pre, 1); + assert_eq!(res.inside, 726); + assert_eq!(res.post, 1); assert_eq!(res.raco, 1); Ok(()) } #[test] - fn read_blocks_many_3() -> Result<(), Error> { - use chrono::{DateTime, Utc}; - let _early = "2021-08-01T00:00:00Z"; - let _late = "2021-10-07T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + fn read_blocks_many_3_basic() -> Result<(), Error> { + let dtbeg = "2021-11-09T10:00:00Z"; + let dtend = "2021-11-09T13:00:00Z"; let range = NanoRange { - beg: tons(&dtbeg), - end: tons(&dtend), + beg: tons(&dtbeg.parse()?), + 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 _early = "2021-08-01T00:00:00Z"; - let _late = "2021-10-07T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + let dtbeg = "2021-11-09T10:00:00Z"; + let dtend = "2021-11-09T13:00:00Z"; let range = NanoRange { - beg: tons(&dtbeg), - end: tons(&dtend), + beg: tons(&dtbeg.parse()?), + 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> { - use chrono::{DateTime, Utc}; - let _early = "2020-01-01T00:00:00Z"; - let _late = "2021-10-07T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + fn read_blocks_many_4_basic() -> Result<(), Error> { + let dtbeg = "2020-11-09T10:00:00Z"; + let dtend = "2021-11-09T13:00:00Z"; let range = NanoRange { - beg: tons(&dtbeg), - end: tons(&dtend), + beg: tons(&dtbeg.parse()?), + 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 _early = "2020-01-01T00:00:00Z"; - let _late = "2021-10-07T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + let dtbeg = "2020-11-09T10:00:00Z"; + let dtend = "2021-11-09T13:00:00Z"; let range = NanoRange { - beg: tons(&dtbeg), - end: tons(&dtend), + beg: tons(&dtbeg.parse()?), + 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> { - use chrono::{DateTime, Utc}; - let _early = "2021-10-01T00:00:00Z"; - let _late = "2021-12-01T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + fn read_blocks_late_basic() -> Result<(), Error> { + let dtbeg = "2021-11-09T10:00:00Z"; + let dtend = "2022-11-09T13:00:00Z"; let range = NanoRange { - beg: tons(&dtbeg), - end: tons(&dtend), + beg: tons(&dtbeg.parse()?), + 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 _early = "2021-10-01T00:00:00Z"; - let _late = "2021-12-01T00:00:00Z"; - let dtbeg: DateTime = _early.parse()?; - let dtend: DateTime = _late.parse()?; - fn tons(dt: &DateTime) -> u64 { - dt.timestamp() as u64 * SEC + dt.timestamp_subsec_nanos() as u64 - } + let dtbeg = "2021-11-09T10:00:00Z"; + let dtend = "2022-11-09T13:00:00Z"; let range = NanoRange { - beg: tons(&dtbeg), - end: tons(&dtend), + beg: tons(&dtbeg.parse()?), + 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(()) diff --git a/daqbufp2/src/test/binnedjson.rs b/daqbufp2/src/test/binnedjson.rs index 2711e8f..9542d90 100644 --- a/daqbufp2/src/test/binnedjson.rs +++ b/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 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]}"##; + let (res, jsstr) = + 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 { +) -> Result<(BinnedResponse, String), Error> { let t1 = Utc::now(); let node0 = &cluster.nodes[0]; let beg_date: DateTime = 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 res: BinnedResponse = serde_json::from_str(res.as_str())?; - Ok(res) + let ret: BinnedResponse = serde_json::from_str(res.as_str())?; + Ok((ret, res)) }