use std::str::FromStr;
use serde_json::Value;
#[derive(Debug, Default, Clone)]
pub struct BadgeInput {
pub all_refs_resolved: bool,
pub harness_registered: bool,
pub all_metrics_registered: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Badge {
RefsResolved,
HarnessRegistered,
MetricRegistered,
EnvPinned,
Redacted,
}
impl Badge {
pub const ALL: [Badge; 5] = [
Badge::RefsResolved,
Badge::HarnessRegistered,
Badge::MetricRegistered,
Badge::EnvPinned,
Badge::Redacted,
];
pub const fn as_str(self) -> &'static str {
match self {
Badge::RefsResolved => "refs_resolved",
Badge::HarnessRegistered => "harness_registered",
Badge::MetricRegistered => "metric_registered",
Badge::EnvPinned => "env_pinned",
Badge::Redacted => "redacted",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[error("not a badge: {0:?}")]
pub struct ParseBadgeError(String);
impl FromStr for Badge {
type Err = ParseBadgeError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Badge::ALL
.into_iter()
.find(|b| b.as_str() == s)
.ok_or_else(|| ParseBadgeError(s.to_string()))
}
}
impl std::fmt::Display for Badge {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
pub fn compute(value: &Value, input: &BadgeInput) -> Vec<Badge> {
let mut out = Vec::new();
if input.all_refs_resolved {
out.push(Badge::RefsResolved);
}
if input.harness_registered {
out.push(Badge::HarnessRegistered);
}
if input.all_metrics_registered {
out.push(Badge::MetricRegistered);
}
if env_pinned(value) {
out.push(Badge::EnvPinned);
}
if value.pointer("/redaction/applied") == Some(&Value::Bool(true)) {
out.push(Badge::Redacted);
}
out
}
fn env_pinned(value: &Value) -> bool {
let non_empty = |p: &str| {
value
.pointer(p)
.and_then(Value::as_str)
.is_some_and(|s| !s.is_empty())
};
value.pointer("/env/git/dirty") == Some(&Value::Bool(false))
&& non_empty("/env/git/commit")
&& non_empty("/trial/sandbox/digest")
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
use serde_json::json;
fn pinned() -> Value {
json!({
"env": {"git": {"commit": "abc", "dirty": false}},
"trial": {"sandbox": {"image": "x", "digest": "sha256:1"}},
})
}
#[test]
fn record_only_badges() {
let none = BadgeInput::default();
assert_eq!(compute(&pinned(), &none), vec![Badge::EnvPinned]);
let mut v = pinned();
v["env"]["git"]["dirty"] = json!(true);
assert_eq!(compute(&v, &none), vec![]);
let mut v = pinned();
v["env"]["git"]["commit"] = json!("");
assert_eq!(compute(&v, &none), vec![]);
let mut v = pinned();
v["trial"]["sandbox"]["digest"] = json!(null);
assert_eq!(compute(&v, &none), vec![]);
let v = json!({"redaction": {"applied": true}});
assert_eq!(compute(&v, &none), vec![Badge::Redacted]);
let v = json!({"redaction": {"applied": false}});
assert_eq!(compute(&v, &none), vec![]);
}
#[test]
fn input_badges_and_order() {
let input = BadgeInput {
all_refs_resolved: true,
harness_registered: true,
all_metrics_registered: true,
};
let mut v = pinned();
v["redaction"] = json!({"applied": true});
assert_eq!(compute(&v, &input), Badge::ALL.to_vec());
assert_eq!(
compute(&json!({}), &input),
vec![
Badge::RefsResolved,
Badge::HarnessRegistered,
Badge::MetricRegistered
]
);
}
#[test]
fn names_round_trip() {
for b in Badge::ALL {
assert_eq!(b.as_str().parse::<Badge>().unwrap(), b);
}
assert!("verified".parse::<Badge>().is_err());
}
}