use drishti::native_host::pattern::{match_pattern, validate_pattern};
use drishti::native_host::protocol::{JsonValue, PayloadPredicate, SignalEnvelope, SignalPattern};
use lgwks_std::json::json;
#[path = "support/fixtures.rs"]
mod fixtures;
fn envelope(kind: &str, payload: JsonValue) -> Result<SignalEnvelope, String> {
Ok(SignalEnvelope::new(
String::from("signal"),
String::from(kind),
drishti::native_host::protocol::SourceKind::Widget,
String::from("widget"),
fixtures::session("tenant")?,
payload,
String::from("2026-11-03T00:00:00Z"),
))
}
fn globbed(glob: &str) -> SignalPattern {
SignalPattern::new(String::from(glob), None)
}
fn assert_match(
pattern: &SignalPattern,
kind: &str,
payload: JsonValue,
want: bool,
) -> Result<(), String> {
let got = match_pattern(&envelope(kind, payload)?, pattern);
(got == want).then_some(()).ok_or_else(|| {
format!(
"match(kind={kind:?}, glob={:?}) = {got}, want {want}",
pattern.kind_glob()
)
})
}
fn assert_glob(glob: &str, kind: &str, want: bool) -> Result<(), String> {
assert_match(&globbed(glob), kind, JsonValue::Null, want)
}
#[test]
fn kind_globs_match() -> Result<(), String> {
assert_glob("forms.submitted", "forms.submitted", true)?;
assert_glob("forms.submitted", "forms.other", false)?;
assert_match(
&globbed("forms.*"),
"forms.submitted",
JsonValue::Null,
true,
)?;
assert_match(&globbed("forms.*"), "forms.a.b", JsonValue::Null, false)?;
assert_match(&globbed("forms.**"), "forms.a.b.c", JsonValue::Null, true)?;
assert_match(&globbed("forms.**"), "forms", JsonValue::Null, true)?;
assert_match(&globbed("a.**"), "a.b.c", JsonValue::Null, true)?;
assert_match(&globbed("a.**"), "a.b.d.e", JsonValue::Null, true)?;
assert_match(&globbed("**"), "anything.at.all", JsonValue::Null, true)?;
assert_match(&globbed("*"), "single", JsonValue::Null, true)?;
assert_match(&globbed("*"), "two.segments", JsonValue::Null, false)?;
Ok(())
}
#[test]
fn predicates_filter() -> Result<(), String> {
let payload = JsonValue::from_json(&json!({
"status": "ok",
"count": 3,
"flag": true,
"nested": { "deep": "yes" },
}));
let eq = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::eq(
String::from("status"),
JsonValue::String(String::from("ok")),
)),
);
assert_match(&eq, "any.kind", payload.clone(), true)?;
let missing = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::eq(
String::from("absent"),
JsonValue::String(String::from("ok")),
)),
);
assert_match(&missing, "any.kind", payload.clone(), false)?;
let cross = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::eq(
String::from("count"),
JsonValue::Bool(true),
)),
);
assert_match(&cross, "any.kind", payload.clone(), false)?;
let cross_number = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::eq(
String::from("flag"),
JsonValue::Number(1.0),
)),
);
assert_match(&cross_number, "any.kind", payload.clone(), false)?;
let number = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::eq(
String::from("count"),
JsonValue::Number(3.0),
)),
);
assert_match(&number, "any.kind", payload.clone(), true)?;
let nested = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::exists(String::from("nested.deep"))),
);
assert_match(&nested, "any.kind", payload.clone(), true)?;
let combined = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::And(vec![
PayloadPredicate::exists(String::from("status")),
PayloadPredicate::Or(vec![
PayloadPredicate::eq(
String::from("status"),
JsonValue::String(String::from("nope")),
),
PayloadPredicate::neq(String::from("count"), JsonValue::Number(4.0)),
]),
])),
);
assert_match(&combined, "any.kind", payload.clone(), true)?;
let neq_missing = SignalPattern::new(
String::from("**"),
Some(PayloadPredicate::neq(
String::from("absent"),
JsonValue::String(String::from("x")),
)),
);
assert_match(&neq_missing, "any.kind", payload, false)?;
Ok(())
}
#[test]
fn invalid_patterns_never_match() -> Result<(), String> {
for bad in ["", "a.**.b"] {
let pattern = globbed(bad);
if validate_pattern(&pattern) {
return Err(format!("{bad:?} must be invalid"));
}
if match_pattern(&envelope("a.b", JsonValue::Null)?, &pattern) {
return Err(format!("{bad:?} must never match"));
}
}
let seventeen = (0..17)
.map(|index| format!("s{index}"))
.collect::<Vec<_>>()
.join(".");
if validate_pattern(&globbed(&seventeen)) {
return Err(String::from("17 segments must be invalid"));
}
Ok(())
}