use std::collections::BTreeMap;
use serde_json::Value;
use super::runner::StepOutput;
use crate::core::Result;
pub fn json_matches(expected: &Value, actual: &Value) -> bool {
match (expected, actual) {
(Value::Number(a), Value::Number(b)) => a.as_f64() == b.as_f64(),
(Value::Object(e), Value::Object(a)) => e
.iter()
.all(|(k, v)| a.get(k).is_some_and(|av| json_matches(v, av))),
(Value::Array(e), Value::Array(a)) => {
e.len() == a.len() && e.iter().zip(a).all(|(x, y)| json_matches(x, y))
}
(e, a) => e == a,
}
}
fn type_name(v: &Value) -> &'static str {
match v {
Value::Null => "null",
Value::Bool(_) => "boolean",
Value::Number(_) => "number",
Value::String(_) => "string",
Value::Array(_) => "array",
Value::Object(_) => "object",
}
}
fn count_of(out: &StepOutput) -> std::result::Result<usize, String> {
if let Some(n) = out.count {
return Ok(n);
}
match &out.value {
Value::Array(a) => Ok(a.len()),
Value::Object(o) => match o.get("spans") {
Some(Value::Array(spans)) => Ok(spans.len()),
_ => Ok(o.len()),
},
other => Err(format!("result of type {} has no count", type_name(other))),
}
}
fn contains(haystack: &Value, needle: &Value) -> std::result::Result<bool, String> {
match (haystack, needle) {
(Value::Array(items), n) => Ok(items.iter().any(|i| json_matches(n, i))),
(Value::String(s), Value::String(n)) => Ok(s.contains(n.as_str())),
(h, _) => Err(format!("cannot apply contains to a {}", type_name(h))),
}
}
fn sort_key(v: &Value) -> String {
match v {
Value::Object(o) => o
.get("name")
.and_then(Value::as_str)
.map(str::to_owned)
.unwrap_or_else(|| v.to_string()),
Value::String(s) => s.clone(),
other => other.to_string(),
}
}
fn check_tree(spec: &Value, value: &Value) -> std::result::Result<(), String> {
let spans = value
.get("spans")
.and_then(Value::as_array)
.ok_or("result has no spans")?;
let names: BTreeMap<&str, &str> = spans
.iter()
.filter_map(|s| Some((s.get("spanId")?.as_str()?, s.get("name")?.as_str()?)))
.collect();
let spec = spec
.as_object()
.ok_or("tree expectation must be an object")?;
for (parent, children) in spec {
let wanted = children
.as_array()
.ok_or("tree children must be an array")?;
let mut actual: Vec<&str> = spans
.iter()
.filter(|s| {
s.get("parentSpanId")
.and_then(Value::as_str)
.and_then(|p| names.get(p))
.is_some_and(|n| n == parent)
})
.filter_map(|s| s.get("name").and_then(Value::as_str))
.collect();
actual.sort_unstable();
let mut wanted: Vec<&str> = wanted.iter().filter_map(Value::as_str).collect();
wanted.sort_unstable();
if actual != wanted {
return Err(format!(
"children of {parent:?} are {actual:?}, expected {wanted:?}"
));
}
}
Ok(())
}
fn flag(v: &Value) -> bool {
v.as_bool().unwrap_or(false)
}
pub fn check_expectation(
expect: &Value,
outcome: &Result<StepOutput>,
) -> std::result::Result<(), String> {
let expect = expect.as_object().ok_or("expect must be an object")?;
if let Some(code) = expect.get("error") {
let code = code.as_str().ok_or("expect.error must be a string")?;
return match outcome {
Err(e) if e.code().as_str() == code => Ok(()),
Err(e) => Err(format!("expected error {code}, got {} ({e})", e.code())),
Ok(_) => Err(format!("expected error {code}, got success")),
};
}
let out = match outcome {
Ok(out) => out,
Err(e) => return Err(format!("unexpected error {}: {e}", e.code())),
};
for (key, want) in expect {
let ok = match key.as_str() {
"reveal" => {
let want = want.as_str().ok_or("expect.reveal must be a string")?;
if out.reveal.as_deref() != Some(want) {
return Err("revealed value differs from the expected value".to_owned());
}
true
}
"equals" => json_matches(want, &out.value),
"null" => out.value.is_null() == flag(want),
"notNull" => !out.value.is_null() == flag(want),
"true" => (out.value == Value::Bool(true)) == flag(want),
"false" => (out.value == Value::Bool(false)) == flag(want),
"contains" => contains(&out.value, want)?,
"notContains" => !contains(&out.value, want)?,
"count" => Some(count_of(out)? as u64) == want.as_u64(),
"minCount" => want
.as_u64()
.is_some_and(|n| count_of(out).is_ok_and(|c| c as u64 >= n)),
"sorted" => {
let items = out.value.as_array().ok_or("sorted applies to arrays")?;
let keys: Vec<String> = items.iter().map(sort_key).collect();
keys.windows(2).all(|w| w[0] <= w[1]) == flag(want)
}
"type" => Some(type_name(&out.value)) == want.as_str(),
"stringForm" => {
let spec = want.as_object().ok_or("stringForm must be an object")?;
if let Some(n) = spec.get("notContains").and_then(Value::as_str) {
if out.display.contains(n) {
return Err("string form contains a forbidden value".to_owned());
}
}
if let Some(n) = spec.get("contains").and_then(Value::as_str) {
if !out.display.contains(n) {
return Err(format!("string form does not contain {n:?}"));
}
}
true
}
"tree" => {
check_tree(want, &out.value)?;
true
}
other => return Err(format!("unknown expectation {other:?}")),
};
if !ok {
return Err(format!(
"expectation {key} = {want} not met by {}",
out.value
));
}
}
Ok(())
}