use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use thiserror::Error;
pub const RESULT_SCHEMA_VERSION: u32 = 1;
pub const OLDEST_READABLE_RESULT_VERSION: u32 = if RESULT_SCHEMA_VERSION > 1 {
RESULT_SCHEMA_VERSION - 1
} else {
1
};
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum ResultReadError {
#[error(
"result_version {found} is not readable by this build: it reads \
{oldest}..={newest}, and payloads with no `result_version` at all"
)]
UnsupportedVersion {
found: u32,
oldest: u32,
newest: u32,
},
#[error("payload is not a RunResult: {message}")]
Malformed {
message: String,
},
}
pub fn can_read(version: Option<u32>) -> bool {
match version {
None => true,
Some(v) => (OLDEST_READABLE_RESULT_VERSION..=RESULT_SCHEMA_VERSION).contains(&v),
}
}
pub fn check_readable(version: Option<u32>) -> Result<(), ResultReadError> {
match version {
v if can_read(v) => Ok(()),
None => Err(ResultReadError::UnsupportedVersion {
found: 0,
oldest: OLDEST_READABLE_RESULT_VERSION,
newest: RESULT_SCHEMA_VERSION,
}),
Some(found) => Err(ResultReadError::UnsupportedVersion {
found,
oldest: OLDEST_READABLE_RESULT_VERSION,
newest: RESULT_SCHEMA_VERSION,
}),
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StepResult {
pub name: String,
pub passed: bool,
pub detail: String,
pub screen: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AssertionResult {
pub name: String,
pub passed: bool,
pub detail: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RunResult {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub result_version: Option<u32>,
pub recipe_name: String,
pub passed: bool,
pub exit_code: Option<i32>,
pub duration_seconds: f64,
pub priority: String,
pub execution: String,
pub renderer: String,
pub score: f64,
pub steps: Vec<StepResult>,
pub assertions: Vec<AssertionResult>,
pub artifacts: BTreeMap<String, String>,
}
impl RunResult {
pub fn score_from_assertions(assertions: &[AssertionResult]) -> f64 {
if assertions.is_empty() {
return 1.0;
}
let passed = assertions.iter().filter(|a| a.passed).count();
if passed == assertions.len() {
1.0
} else {
passed as f64 / assertions.len() as f64
}
}
pub fn to_json_value(&self) -> serde_json::Value {
serde_json::to_value(self).expect("RunResult is serializable")
}
pub fn to_json_pretty(&self) -> String {
let mut s = serde_json::to_string_pretty(self).expect("RunResult is serializable");
s.push('\n');
s
}
pub fn from_json_value(value: &serde_json::Value) -> Result<Self, ResultReadError> {
check_readable(declared_version(value)?)?;
serde_json::from_value(value.clone()).map_err(|e| ResultReadError::Malformed {
message: e.to_string(),
})
}
pub fn from_json_str(text: &str) -> Result<Self, ResultReadError> {
let value: serde_json::Value =
serde_json::from_str(text).map_err(|e| ResultReadError::Malformed {
message: e.to_string(),
})?;
Self::from_json_value(&value)
}
}
fn declared_version(value: &serde_json::Value) -> Result<Option<u32>, ResultReadError> {
match value.get("result_version") {
None | Some(serde_json::Value::Null) => Ok(None),
Some(found) => found
.as_u64()
.and_then(|n| u32::try_from(n).ok())
.map(Some)
.ok_or_else(|| ResultReadError::Malformed {
message: format!("`result_version` is not an unsigned integer: {found}"),
}),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn run(result_version: Option<u32>) -> RunResult {
RunResult {
result_version,
recipe_name: "login".to_string(),
passed: true,
exit_code: Some(0),
duration_seconds: 0.0,
priority: "P0".to_string(),
execution: "scripted".to_string(),
renderer: "default".to_string(),
score: 1.0,
steps: vec![],
assertions: vec![],
artifacts: BTreeMap::new(),
}
}
#[test]
fn a_payload_this_build_writes_declares_its_version() {
let json = run(Some(RESULT_SCHEMA_VERSION)).to_json_value();
assert_eq!(json["result_version"], RESULT_SCHEMA_VERSION);
}
#[test]
fn an_absent_version_is_readable_and_is_not_version_zero() {
assert!(can_read(None));
assert!(!can_read(Some(0)));
}
#[test]
fn the_readable_window_is_current_and_one_back() {
assert!(can_read(Some(RESULT_SCHEMA_VERSION)));
assert!(can_read(Some(OLDEST_READABLE_RESULT_VERSION)));
assert!(!can_read(Some(RESULT_SCHEMA_VERSION + 1)));
}
#[test]
fn refusing_names_the_version_found_and_the_window_supported() {
let err = check_readable(Some(RESULT_SCHEMA_VERSION + 9)).expect_err("unreadable");
let message = err.to_string();
assert!(
message.contains(&(RESULT_SCHEMA_VERSION + 9).to_string()),
"{message}"
);
assert!(
message.contains(&format!(
"{OLDEST_READABLE_RESULT_VERSION}..={RESULT_SCHEMA_VERSION}"
)),
"{message}"
);
}
#[test]
fn a_foreign_payload_with_no_version_still_reads() {
let mut json = run(None).to_json_value();
assert!(
json.get("result_version").is_none(),
"absent must stay absent: {json}"
);
json["something_we_do_not_know"] = serde_json::json!(true);
let back = RunResult::from_json_value(&json).expect("foreign payload reads");
assert_eq!(back.result_version, None);
assert_eq!(back.recipe_name, "login");
}
#[test]
fn reading_a_foreign_payload_does_not_stamp_it_with_a_version() {
let foreign = run(None).to_json_value();
let back = RunResult::from_json_value(&foreign).expect("reads");
assert_eq!(back.to_json_value(), foreign);
}
#[test]
fn a_payload_from_the_future_is_refused_by_version_not_by_field() {
let mut json = run(Some(RESULT_SCHEMA_VERSION + 1)).to_json_value();
json.as_object_mut().expect("object").remove("score");
assert_eq!(
RunResult::from_json_value(&json),
Err(ResultReadError::UnsupportedVersion {
found: RESULT_SCHEMA_VERSION + 1,
oldest: OLDEST_READABLE_RESULT_VERSION,
newest: RESULT_SCHEMA_VERSION,
})
);
}
#[test]
fn a_version_that_is_not_a_number_is_malformed_not_absent() {
let mut json = run(Some(RESULT_SCHEMA_VERSION)).to_json_value();
json["result_version"] = serde_json::json!("1");
assert!(matches!(
RunResult::from_json_value(&json),
Err(ResultReadError::Malformed { .. })
));
}
#[test]
fn an_explicit_null_version_reads_as_absent() {
let mut json = run(Some(RESULT_SCHEMA_VERSION)).to_json_value();
json["result_version"] = serde_json::Value::Null;
let back = RunResult::from_json_value(&json).expect("null reads as absent");
assert_eq!(back.result_version, None);
}
#[test]
fn a_payload_predating_the_version_field_still_deserialises() {
let text = r#"{
"recipe_name": "login", "passed": true, "exit_code": 0,
"duration_seconds": 1.5, "priority": "P0", "execution": "scripted",
"renderer": "default", "score": 1.0,
"steps": [], "assertions": [], "artifacts": {}
}"#;
let parsed: RunResult = serde_json::from_str(text).expect("plain serde still works");
assert_eq!(parsed.result_version, None);
assert_eq!(
RunResult::from_json_str(text).expect("checked read"),
parsed
);
}
}