grow-graylog 0.2.0

Rust SDK for Graylog Open by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! Expectation evaluation for conformance steps (SPEC §6).

use std::collections::BTreeMap;

use serde_json::Value;

use super::runner::StepOutput;
use crate::core::Result;

/// Deep JSON match: numbers compare numerically, objects in `expected` match as a subset.
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)
}

/// Checks `expect` (variables already substituted) against a step outcome.
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(())
}