use oakum::state::{ChangedPackage, RetiredPackage};
use serde::Serialize;
use super::preconditions::GatedLooks;
use super::verdict::{first_line, Verdict};
use super::Outcome;
pub(super) const SCHEMA_VERSION: u32 = 1;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "kebab-case")]
enum LookOutcome {
Ok,
Reported,
Unverified,
Error,
NotAsked,
}
impl From<Outcome> for LookOutcome {
fn from(outcome: Outcome) -> Self {
match outcome {
Outcome::Error => Self::Error,
Outcome::Unverified => Self::Unverified,
}
}
}
#[derive(Serialize)]
struct RefusalRow {
outcome: LookOutcome,
summary: String,
#[serde(skip_serializing_if = "Vec::is_empty")]
detail: Vec<String>,
deciding: bool,
}
#[derive(Serialize)]
struct LookRow {
look: &'static str,
outcome: LookOutcome,
#[serde(skip_serializing_if = "Vec::is_empty")]
refusals: Vec<RefusalRow>,
#[serde(skip_serializing_if = "Vec::is_empty")]
reports: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
changed: Option<Vec<ChangedPackage>>,
#[serde(skip_serializing_if = "Option::is_none")]
retired: Option<Vec<RetiredPackage>>,
}
#[derive(Serialize)]
pub(super) struct ScopeRow {
selected: usize,
packages: usize,
#[serde(skip_serializing_if = "Option::is_none")]
base: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
base_unavailable: Option<String>,
gating: GatedLooks,
}
impl ScopeRow {
pub(super) fn of(
selected: usize,
packages: usize,
base: Result<&str, &str>,
gating: GatedLooks,
) -> Self {
let (base, base_unavailable) = match base {
Ok(reference) => (Some(reference.to_owned()), None),
Err(why) => (None, Some(why.to_owned())),
};
Self {
selected,
packages,
base,
base_unavailable,
gating,
}
}
}
#[derive(Serialize)]
pub(super) struct CheckReport {
schema_version: u32,
tool_version: &'static str,
outcome: LookOutcome,
scope: ScopeRow,
looks: Vec<LookRow>,
}
impl CheckReport {
pub(super) fn of(
verdict: &Verdict,
scope: ScopeRow,
asked: &[&'static str],
universe: &[&'static str],
) -> Self {
let looks = universe
.iter()
.chain(asked.iter().filter(|look| !universe.contains(look)))
.map(|name| row(verdict, asked, name))
.collect();
Self {
schema_version: SCHEMA_VERSION,
tool_version: env!("CARGO_PKG_VERSION"),
outcome: verdict
.refusals()
.find_map(|(block, deciding)| deciding.then(|| block.error.class().into()))
.unwrap_or_else(|| {
if verdict.said().next().is_some() {
LookOutcome::Reported
} else {
LookOutcome::Ok
}
}),
scope,
looks,
}
}
}
fn row(verdict: &Verdict, asked: &[&'static str], name: &'static str) -> LookRow {
if !asked.contains(&name) {
return LookRow {
look: name,
outcome: LookOutcome::NotAsked,
refusals: Vec::new(),
reports: Vec::new(),
changed: None,
retired: None,
};
}
let raised: Vec<(&super::verdict::Block, bool)> = verdict
.refusals()
.filter(|(block, _)| block.raised_by_look(name))
.collect();
let worst = raised.iter().map(|(block, _)| block.error.class()).min();
let refusals: Vec<RefusalRow> = raised
.iter()
.map(|(block, deciding)| RefusalRow {
outcome: block.error.class().into(),
summary: first_line(&block.error.detail()),
detail: block
.error
.detail()
.lines()
.skip(1)
.map(str::to_owned)
.chain(block.lines.iter().cloned())
.collect(),
deciding: *deciding,
})
.collect();
let reports: Vec<String> = verdict
.said()
.filter(|(look, _)| *look == name)
.map(|(_, line)| line.to_owned())
.collect();
let outcome = worst.map_or(
if reports.is_empty() {
LookOutcome::Ok
} else {
LookOutcome::Reported
},
LookOutcome::from,
);
LookRow {
look: name,
outcome,
refusals,
reports,
changed: verdict.changed(name).map(<[ChangedPackage]>::to_vec),
retired: verdict.retired(name).map(<[RetiredPackage]>::to_vec),
}
}
#[cfg(test)]
mod tests {
use super::{CheckReport, GatedLooks, ScopeRow};
use crate::cli::verdict::{carry, LookReport, Refusal};
use crate::cli::CliError;
fn scope() -> ScopeRow {
ScopeRow::of(1, 2, Ok("HEAD~1"), GatedLooks::of_check(false))
}
fn document(reports: Vec<(&'static str, LookReport)>) -> serde_json::Value {
let verdict = carry(reports);
serde_json::to_value(CheckReport::of(
&verdict,
scope(),
&["one"],
&["one", "two"],
))
.expect("a document")
}
#[test]
fn the_wire_words_are_kebab_case_and_distinct() {
let refusing = LookReport::refusing(vec![Refusal::bare(CliError::unverified(
"unverified: could not look\nwhy",
))]);
let value = document(vec![("one", refusing)]);
assert_eq!(value["outcome"], "unverified");
assert_eq!(value["looks"][0]["outcome"], "unverified");
assert_eq!(
value["looks"][0]["refusals"][0]["summary"],
"could not look"
);
assert_eq!(value["looks"][0]["refusals"][0]["detail"][0], "why");
assert_eq!(value["looks"][0]["refusals"][0]["deciding"], true);
assert_eq!(value["looks"][1]["look"], "two");
assert_eq!(value["looks"][1]["outcome"], "not-asked");
}
#[test]
fn a_clean_row_carries_neither_refusals_nor_reports() {
let value = document(vec![("one", LookReport::default())]);
assert_eq!(value["outcome"], "ok");
assert_eq!(value["looks"][0]["outcome"], "ok");
assert!(value["looks"][0]["refusals"].is_null());
assert!(value["looks"][0]["reports"].is_null());
}
#[test]
fn the_scope_keeps_its_two_counts_apart() {
let value = document(vec![("one", LookReport::default())]);
assert_eq!(value["scope"]["selected"], 1);
assert_eq!(value["scope"]["packages"], 2);
assert_eq!(value["scope"]["base"], "HEAD~1");
assert!(value["scope"]["base_unavailable"].is_null());
}
#[test]
fn a_base_that_cannot_be_named_carries_why() {
let verdict = carry(vec![("one", LookReport::default())]);
let value = serde_json::to_value(CheckReport::of(
&verdict,
ScopeRow::of(1, 1, Err("no commit yet"), GatedLooks::of_check(true)),
&["one"],
&["one"],
))
.expect("a document");
assert!(value["scope"]["base"].is_null());
assert_eq!(value["scope"]["base_unavailable"], "no commit yet");
assert_eq!(
value["scope"]["gating"],
serde_json::json!(["coverage", "notes"])
);
}
#[test]
fn a_shared_deciding_refusal_is_marked_under_every_look_that_raised_it() {
let same = || CliError::unverified("unverified: shallow clone");
let value = serde_json::to_value(CheckReport::of(
&carry(vec![
("one", LookReport::refusing(vec![Refusal::bare(same())])),
("two", LookReport::refusing(vec![Refusal::bare(same())])),
]),
scope(),
&["one", "two"],
&["one", "two"],
))
.expect("a document");
for row in value["looks"].as_array().expect("looks") {
assert_eq!(row["refusals"][0]["deciding"], true, "{value}");
}
}
}