use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckPayload {
#[serde(alias = "govern_version")]
pub g8_version: String,
pub errors: Vec<CheckErrorItem>,
pub exit_code: i32,
#[serde(skip_serializing_if = "Option::is_none")]
pub enforcement_disabled: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckErrorItem {
pub capability: String,
pub file: String,
pub line: u32,
pub reason: PairingReason,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PairingReason {
NoMatchingConvergenceTest,
StubExpired,
StubMissingSince,
DuplicateCapabilityName,
}
impl PairingReason {
pub fn as_str(self) -> &'static str {
match self {
PairingReason::NoMatchingConvergenceTest => "no_matching_convergence_test",
PairingReason::StubExpired => "stub_expired",
PairingReason::StubMissingSince => "stub_missing_since",
PairingReason::DuplicateCapabilityName => "duplicate_capability_name",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn check_payload_omits_enforcement_disabled_when_none() {
let payload = CheckPayload {
g8_version: "0.1.0".to_string(),
errors: vec![],
exit_code: 0,
enforcement_disabled: None,
};
let value = serde_json::to_value(&payload).unwrap();
assert!(value.get("enforcement_disabled").is_none());
}
#[test]
fn check_payload_includes_enforcement_disabled_when_some() {
let payload = CheckPayload {
g8_version: "0.1.0".to_string(),
errors: vec![],
exit_code: 0,
enforcement_disabled: Some(true),
};
let value = serde_json::to_value(&payload).unwrap();
assert_eq!(value["enforcement_disabled"], serde_json::json!(true));
}
#[test]
fn pairing_reason_serializes_to_locked_snake_case_strings() {
assert_eq!(
serde_json::to_value(PairingReason::NoMatchingConvergenceTest).unwrap(),
serde_json::json!("no_matching_convergence_test")
);
assert_eq!(
serde_json::to_value(PairingReason::DuplicateCapabilityName).unwrap(),
serde_json::json!("duplicate_capability_name")
);
}
#[test]
fn pairing_reason_as_str_matches_serde_output() {
for reason in [
PairingReason::NoMatchingConvergenceTest,
PairingReason::StubExpired,
PairingReason::StubMissingSince,
PairingReason::DuplicateCapabilityName,
] {
let serialized = serde_json::to_value(reason).unwrap();
assert_eq!(serialized, serde_json::json!(reason.as_str()));
}
}
#[test]
fn check_error_item_round_trips() {
let item = CheckErrorItem {
capability: "http-fetch".to_string(),
file: "src/lib.rs".to_string(),
line: 42,
reason: PairingReason::StubExpired,
};
let value = serde_json::to_value(&item).unwrap();
let back: CheckErrorItem = serde_json::from_value(value).unwrap();
assert_eq!(back.capability, "http-fetch");
assert_eq!(back.reason, PairingReason::StubExpired);
}
}