use std::fmt::Write;
use oakum::state::{
ChangedPackage, CoverageLook, EcosystemName, PackageRef, ReleaseSource, ReleaseState,
};
use super::config::{unresolved_scope_line, UNMANAGED_FIX};
use super::reasons;
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum NextStep {
BumpFiles {
pending: usize,
generate: bool,
generate_from: Option<String>,
},
Commits,
}
impl NextStep {
fn cover_uncovered(&self) -> String {
match self {
Self::BumpFiles { generate_from, .. } => {
let mut line = String::from(
"Cover each with `oakum add --packages <package>:<level>`, or `<package>:none` to cover it without a release",
);
if let Some(base) = generate_from {
let _ = write!(
line,
"; `oakum generate --from {base}` writes them from conventional commits"
);
}
line.push('.');
line
}
Self::Commits => {
String::from("Name each in a conventional commit, or in a path that maps to it.")
}
}
}
}
pub(super) fn render_summary(state: &ReleaseState, next: Option<&NextStep>) -> String {
let mut out = String::from("## Release plan\n\n");
if state.packages().is_empty() {
out.push_str("No packages planned.\n");
if let Some(NextStep::BumpFiles {
pending: 0,
generate,
..
}) = next
{
if !state.manages_nothing() && !state.selection_empty() {
out.push_str("\nNo bump file is pending in `.changeset`. `oakum add` writes one");
if *generate {
out.push_str(", and `oakum generate` writes one from conventional commits");
}
out.push_str(".\n");
}
}
if state.manages_nothing() {
out.push_str(
"\nThis config manages no package on either axis, so no plan can ever be non-empty; set `private-packages.version` / `private-packages.tag`, or adjust `include`/`exclude`.\n",
);
}
if state.selection_empty() {
out.push_str(
"\n`include`/`exclude` leave no package selected, so no plan can ever name one. `check` does not refuse this, because it is a decision this config states.\n",
);
}
} else {
out.push_str("| Package | From | To | Bump | Source |\n");
out.push_str("| --- | --- | --- | --- | --- |\n");
for pkg in state.packages() {
let _ = match pkg.source() {
ReleaseSource::Intent | ReleaseSource::DependencyUpdate => writeln!(
out,
"| {} (`{}`) | {} | {} | {} | {} |",
pkg.name(),
ecosystem_label(pkg.ecosystem()),
pkg.from_version(),
pkg.to_version(),
pkg.bump().as_str(),
if *pkg.source() == ReleaseSource::DependencyUpdate {
"dependency updates"
} else {
"intent"
},
),
ReleaseSource::Cascade { trigger } => writeln!(
out,
"| {} (`{}`) | {} | {} | {} | cascade from {} ({}) |",
pkg.name(),
ecosystem_label(pkg.ecosystem()),
pkg.from_version(),
pkg.to_version(),
pkg.bump().as_str(),
trigger.name(),
ecosystem_label(trigger.ecosystem()),
),
};
}
}
push_summary_coverage(&mut out, state, next);
if !state.unmanaged().is_empty() {
let _ = write!(
out,
"\nChanged but not version-managed: {}\n{UNMANAGED_FIX}\n",
package_list(state.unmanaged())
);
}
if !state.named_unmanaged().is_empty() {
let _ = write!(
out,
"\nNamed by a commit but not version-managed: {}\n{UNMANAGED_FIX}\n",
package_list(state.named_unmanaged())
);
}
push_unlinked(&mut out, state);
push_unresolved_scopes(&mut out, state);
if !state.awaiting_tag().is_empty() {
let _ = write!(
out,
"\nReleased, awaiting its tag: {}\n{AWAITING_TAG}\n",
package_list(state.awaiting_tag())
);
}
if !state.updates_unread().is_empty() {
let _ = write!(
out,
"\nDependency updates not read: {}\n{UPDATES_UNREAD}\n",
package_list(state.updates_unread())
);
}
push_hand_set(&mut out, state);
if state.coverage() == CoverageLook::Failed {
out.push_str(
"\nCoverage was not checked: git could not diff this tree, so an empty uncovered list is not a clean result.\n",
);
}
out
}
const AWAITING_TAG: &str = "no commits are planned for it until `oakum release` tags the release";
const UPDATES_UNREAD: &str =
"no tag records its last release, so `dependency-updates = \"release\"` reads no range for it; a bump file still releases it";
fn push_releases(out: &mut String, state: &ReleaseState) {
if state.packages().is_empty() {
return;
}
out.push_str("\nThese packages will release:\n\n");
for pkg in state.packages() {
let by = if *pkg.source() == ReleaseSource::DependencyUpdate {
", dependency updates"
} else {
""
};
let _ = writeln!(
out,
"- `{}` {} → {} ({}{by})",
pkg.name(),
pkg.from_version(),
pkg.to_version(),
pkg.bump().as_str(),
);
}
}
fn push_listed(out: &mut String, heading: &str, packages: &[PackageRef], why: &str) {
if packages.is_empty() {
return;
}
let _ = write!(out, "\n{heading}:\n\n");
for pkg in packages {
let _ = writeln!(
out,
"- `{}` ({}) — {why}",
pkg.name(),
ecosystem_label(pkg.ecosystem()),
);
}
}
fn push_summary_coverage(out: &mut String, state: &ReleaseState, next: Option<&NextStep>) {
if !state.uncovered().is_empty() {
out.push_str("\nUncovered:\n\n");
for pkg in uncovered(state) {
let _ = writeln!(
out,
"- {} (`{}`){}",
pkg.id().name(),
ecosystem_label(pkg.id().ecosystem()),
uncovered_detail(pkg)
);
}
if let Some(next) = next {
let _ = write!(out, "\n{}\n", next.cover_uncovered());
}
}
let quiet = releasing_nothing(state);
if !quiet.is_empty() {
out.push_str("\nChanged, releasing nothing:\n\n");
for pkg in quiet {
let _ = writeln!(
out,
"- {} (`{}`){}: {}",
pkg.id().name(),
ecosystem_label(pkg.id().ecosystem()),
reasons::via_clause(pkg),
reasons::covered_phrase(pkg)
);
}
}
}
fn uncovered(state: &ReleaseState) -> impl Iterator<Item = &ChangedPackage> {
state.changed().iter().filter(|pkg| !pkg.is_covered())
}
fn releasing_nothing(state: &ReleaseState) -> Vec<&ChangedPackage> {
state
.changed()
.iter()
.filter(|pkg| {
pkg.releases_nothing()
&& !state.packages().iter().any(|planned| {
planned.name() == pkg.id().name() && planned.ecosystem() == pkg.id().ecosystem()
})
})
.collect()
}
fn uncovered_detail(pkg: &ChangedPackage) -> String {
let via = reasons::via_clause(pkg);
match reason_and_fix(pkg) {
Some(rest) => format!("{via}: {rest}"),
None => via,
}
}
fn reason_and_fix(pkg: &ChangedPackage) -> Option<String> {
let reason = reasons::uncovered_reason_markdown(pkg)?;
Some(match pkg.fix() {
Some(fix) => format!("{reason}: `{fix}`"),
None => reason,
})
}
fn push_hand_set(out: &mut String, state: &ReleaseState) {
if state.hand_set().is_empty() {
return;
}
out.push_str(
"\nBlocked by a version set by hand; `oakum version` refuses this plan until each is fixed:\n\n",
);
for entry in state.hand_set() {
let _ = writeln!(out, "- {}", entry.fix());
}
}
fn push_unlinked(out: &mut String, state: &ReleaseState) {
if state.unlinked().is_empty() {
return;
}
out.push_str("\nNamed like a member, installed from the registry:\n\n");
for entry in state.unlinked() {
let dependent = entry.dependent();
let from = entry
.catalog()
.map_or_else(String::new, |catalog| format!(" from catalog `{catalog}`"));
let alias = if entry.declared_as() == entry.on() {
String::new()
} else {
format!(" as `{}`", entry.declared_as())
};
let _ = writeln!(
out,
"- {} (`{}`) {} `{}`{alias}{from}: `{}` does not match the member's {}",
dependent.name(),
ecosystem_label(dependent.ecosystem()),
entry.table(),
entry.on(),
entry.range(),
entry.member_version(),
);
}
out.push_str(
"\npnpm links none of these to the member. Write `workspace:` where the member is meant; a registry pin needs nothing.\n",
);
}
fn push_unresolved_scopes(out: &mut String, state: &ReleaseState) {
if state.unresolved_scopes().is_empty() {
return;
}
out.push_str("\nReleased by a commit but reaching no package:\n\n");
for commit in state.unresolved_scopes() {
let _ = writeln!(out, "- {}", unresolved_scope_line(commit));
}
}
fn package_list(packages: &[oakum::state::PackageRef]) -> String {
packages
.iter()
.map(|pkg| format!("{} (`{}`)", pkg.name(), ecosystem_label(pkg.ecosystem())))
.collect::<Vec<_>>()
.join(", ")
}
pub(super) const PR_PLAN_MARKER: &str = "<!-- oakum:pr-plan -->";
pub(super) fn render_comment(state: &ReleaseState, next: Option<&NextStep>) -> Option<String> {
let mut out = String::from(PR_PLAN_MARKER);
out.push('\n');
push_hand_set(&mut out, state);
push_releases(&mut out, state);
if !state.uncovered().is_empty() {
out.push_str("\nUncovered:\n\n");
for pkg in uncovered(state) {
let _ = writeln!(
out,
"- `{}` ({}) changed{} with no covering intent{}",
pkg.id().name(),
ecosystem_label(pkg.id().ecosystem()),
reasons::via_clause(pkg),
reason_and_fix(pkg).map_or_else(String::new, |rest| format!("; {rest}"))
);
}
if let Some(next) = next {
let _ = write!(out, "\n{}\n", next.cover_uncovered());
}
}
let quiet = releasing_nothing(state);
if !quiet.is_empty() {
out.push_str("\nChanged, releasing nothing:\n\n");
for pkg in quiet {
let _ = writeln!(
out,
"- `{}` ({}){} — {}",
pkg.id().name(),
ecosystem_label(pkg.id().ecosystem()),
reasons::via_clause(pkg),
reasons::covered_phrase(pkg)
);
}
}
if !state.unmanaged().is_empty() {
out.push_str("\nChanged but not version-managed:\n\n");
for pkg in state.unmanaged() {
let _ = writeln!(
out,
"- `{}` ({}) — {UNMANAGED_FIX}",
pkg.name(),
ecosystem_label(pkg.ecosystem()),
);
}
}
if !state.named_unmanaged().is_empty() {
out.push_str("\nNamed by a commit but not version-managed:\n\n");
for pkg in state.named_unmanaged() {
let _ = writeln!(
out,
"- `{}` ({}) — {UNMANAGED_FIX}",
pkg.name(),
ecosystem_label(pkg.ecosystem()),
);
}
}
push_unresolved_scopes(&mut out, state);
push_listed(
&mut out,
"Released, awaiting its tag",
state.awaiting_tag(),
AWAITING_TAG,
);
push_listed(
&mut out,
"Dependency updates not read",
state.updates_unread(),
UPDATES_UNREAD,
);
if state.manages_nothing() {
out.push_str(
"\nThis config manages no package on either axis, so no plan can ever be non-empty.\n",
);
}
if state.selection_empty() {
out.push_str(
"\n`include`/`exclude` leave no package selected, so no plan can ever name one.\n",
);
}
if state.coverage() == CoverageLook::Failed {
out.push_str(
"\nCoverage was not checked: git could not diff this tree, so an empty uncovered list is not a clean result.\n",
);
}
(out.trim_end() != PR_PLAN_MARKER).then_some(out)
}
const fn ecosystem_label(ecosystem: EcosystemName) -> &'static str {
match ecosystem {
EcosystemName::Cargo => "cargo",
EcosystemName::Npm => "npm",
}
}
#[cfg(test)]
mod renders {
use oakum::plan::{
aggregate, compose, BumpFile, BumpLevel, CascadeAs, Ecosystem, Package, PackageId,
ResolvesDependenciesAt, Versioning, Workspace,
};
use oakum::state::{
ChangedPackage, CoverSource, Coverage, CoverageOutcome, HandSet, ReleaseState,
ReleasingCommit, RenderTarget,
};
use semver::Version;
use super::{NextStep, PR_PLAN_MARKER};
fn render_summary(state: &ReleaseState) -> String {
super::render_summary(state, None)
}
fn render_comment(state: &ReleaseState) -> Option<String> {
super::render_comment(state, None)
}
fn bump_files(pending: usize, generate: bool, generate_from: Option<&str>) -> NextStep {
NextStep::BumpFiles {
pending,
generate,
generate_from: generate_from.map(String::from),
}
}
#[test]
fn an_empty_plan_with_no_bump_file_names_add() {
let state = empty_state(RenderTarget::Status, CoverageOutcome::NotAsked);
let summary = super::render_summary(&state, Some(&bump_files(0, false, None)));
assert!(
summary.contains("No bump file is pending in `.changeset`. `oakum add` writes one.\n"),
"{summary}"
);
assert!(
super::render_summary(&state, Some(&bump_files(0, true, None)))
.contains("and `oakum generate` writes one from conventional commits.")
);
for quiet in [
super::render_summary(&state, Some(&bump_files(1, true, None))),
super::render_summary(&state, Some(&NextStep::Commits)),
super::render_summary(&state, None),
super::render_summary(
&state.clone().managing_nothing(),
Some(&bump_files(0, false, None)),
),
super::render_summary(
&state.clone().selection_emptied(),
Some(&bump_files(0, false, None)),
),
] {
assert!(!quiet.contains("oakum add"), "{quiet}");
}
}
#[test]
fn the_comment_starts_with_the_marker() {
let state = empty_state(
RenderTarget::Comment,
CoverageOutcome::Ran(Coverage {
unmanaged: Vec::new(),
changed: vec![ChangedPackage::new(
cargo("demo"),
Vec::new(),
Vec::new(),
Vec::new(),
None,
)],
}),
);
for next in [None, Some(&NextStep::Commits)] {
let comment = super::render_comment(&state, next).expect("comment");
assert!(comment.starts_with(PR_PLAN_MARKER), "{comment}");
}
}
#[test]
fn an_uncovered_package_names_the_command_that_covers_it() {
let state = empty_state(
RenderTarget::Comment,
CoverageOutcome::Ran(Coverage {
unmanaged: Vec::new(),
changed: vec![ChangedPackage::new(
cargo("demo"),
Vec::new(),
Vec::new(),
Vec::new(),
None,
)],
}),
);
let add = "Cover each with `oakum add --packages <package>:<level>`, or `<package>:none` to cover it without a release.";
let summary = super::render_summary(&state, Some(&bump_files(0, false, None)));
assert!(
summary.contains(&format!("Uncovered:\n\n- demo (`cargo`)\n\n{add}")),
"{summary}"
);
let comment =
super::render_comment(&state, Some(&bump_files(0, false, None))).expect("comment");
assert!(comment.contains(add), "{comment}");
let generate = super::render_summary(&state, Some(&bump_files(0, true, Some("abc123"))));
assert!(
generate.contains(
"; `oakum generate --from abc123` writes them from conventional commits."
),
"{generate}"
);
let commits = super::render_summary(&state, Some(&NextStep::Commits));
assert!(
commits.contains("Name each in a conventional commit"),
"{commits}"
);
assert!(!render_summary(&state).contains("Cover each"));
}
fn cargo(name: &str) -> PackageId {
PackageId::new(Ecosystem::Cargo, name)
}
fn quiet_and_released() -> Vec<ChangedPackage> {
let file = || String::from(".changeset/a.md");
let releaseless = |hash: &str, kind: &str| {
CoverSource::commit(hash.to_owned(), Some(kind.to_owned()), BumpLevel::None)
};
vec![
ChangedPackage::new(
cargo("alpha"),
Vec::new(),
vec![CoverSource::file(file(), BumpLevel::Patch)],
Vec::new(),
None,
),
ChangedPackage::new(
cargo("beta"),
Vec::new(),
vec![CoverSource::file(file(), BumpLevel::None)],
Vec::new(),
None,
),
ChangedPackage::new(
cargo("delta"),
vec![cargo("core")],
vec![
releaseless("1111111aaaa", "refactor"),
releaseless("2222222bbbb", "refactor"),
releaseless("3333333cccc", "test"),
],
Vec::new(),
None,
),
ChangedPackage::new(
cargo("demo"),
Vec::new(),
vec![CoverSource::EmptyFile { file: file() }],
Vec::new(),
None,
),
ChangedPackage::new(
cargo("epsilon"),
Vec::new(),
vec![CoverSource::EmptyFile { file: file() }],
Vec::new(),
None,
),
]
}
#[test]
fn both_renders_escape_a_backtick_in_a_commit_subject() {
let state = empty_state(
RenderTarget::Comment,
CoverageOutcome::Ran(Coverage {
unmanaged: Vec::new(),
changed: vec![ChangedPackage::new(
cargo("demo"),
Vec::new(),
Vec::new(),
ReleasingCommit::new(
String::from("aaaaaaa111"),
String::from("fix: odd ` tick"),
Some(String::from("fix")),
BumpLevel::Patch,
)
.into_iter()
.collect(),
Some(String::from("oakum add --packages demo:patch")),
)],
}),
);
for render in [
render_summary(&state),
render_comment(&state).expect("comment"),
] {
assert!(render.contains("\"fix: odd \\` tick\""), "{render}");
}
}
#[test]
fn a_change_releasing_nothing_is_named_with_what_covers_it() {
let state = planned_state(CoverageOutcome::Ran(Coverage {
unmanaged: Vec::new(),
changed: quiet_and_released(),
}));
let summary = render_summary(&state);
assert!(
summary.contains(
"\nChanged, releasing nothing:\n\n\
- beta (`cargo`): covered by `none` in `.changeset/a.md`\n\
- delta (`cargo`) (via core): covered by commits that release nothing (refactor ×2, test)\n\
- epsilon (`cargo`): covered by the empty bump file `.changeset/a.md`\n"
),
"{summary}"
);
let comment = render_comment(&state).expect("comment");
assert!(
comment.contains(
"\nChanged, releasing nothing:\n\n\
- `beta` (cargo) — covered by `none` in `.changeset/a.md`\n\
- `delta` (cargo) (via core) — covered by commits that release nothing (refactor ×2, test)\n\
- `epsilon` (cargo) — covered by the empty bump file `.changeset/a.md`\n"
),
"{comment}"
);
for render in [summary, comment] {
assert!(!render.contains("alpha"), "it releases: {render}");
assert!(
!render.contains("demo (`cargo`): covered")
&& !render.contains("`demo` (cargo) — covered"),
"the plan releases it: {render}"
);
}
}
fn planned_state(coverage: CoverageOutcome) -> ReleaseState {
let workspace = Workspace::new([Package::new(
cargo("demo"),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
)])
.expect("workspace");
let plan = compose(
&workspace,
&aggregate([BumpFile {
id: String::from("other.md"),
entries: vec![(cargo("demo"), BumpLevel::Patch)],
note: String::new(),
}]),
|_| Versioning::ZeroMajor,
CascadeAs::Patch,
)
.expect("plan");
ReleaseState::from_plan(&plan, coverage, RenderTarget::Status)
}
fn empty_state(target: RenderTarget, coverage: CoverageOutcome) -> ReleaseState {
let workspace = Workspace::new([Package::new(
cargo("demo"),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
)])
.expect("workspace");
let plan = compose(
&workspace,
&aggregate([]),
|_| Versioning::ZeroMajor,
CascadeAs::Patch,
)
.expect("plan");
ReleaseState::from_plan(&plan, coverage, target)
}
fn unmanaged_only() -> Coverage {
Coverage {
unmanaged: vec![cargo("beta")],
changed: Vec::new(),
}
}
#[test]
fn a_comment_carrying_only_unmanaged_packages_is_not_empty() {
let body = render_comment(&empty_state(
RenderTarget::Comment,
CoverageOutcome::Ran(unmanaged_only()),
))
.expect("a state with something to say renders a body");
assert!(body.contains("beta"), "{body}");
assert_ne!(body.trim_end(), PR_PLAN_MARKER);
}
#[test]
fn a_package_named_by_a_commit_reaches_both_renders() {
let state = empty_state(RenderTarget::Comment, CoverageOutcome::NotAsked)
.with_named_unmanaged(vec![cargo("beta")]);
let body = render_comment(&state).expect("a named package is worth saying");
assert!(
body.contains("Named by a commit but not version-managed:\n\n- `beta` (cargo)"),
"{body}"
);
let summary = render_summary(&state);
assert!(
summary.contains("Named by a commit but not version-managed: beta (`cargo`)"),
"{summary}"
);
}
#[test]
fn a_commit_reaching_no_package_reaches_both_renders() {
let state = empty_state(RenderTarget::Comment, CoverageOutcome::NotAsked)
.with_unresolved_scopes(vec![oakum::state::UnresolvedScope {
commit: String::from("0123456789abcdef"),
scope: String::from("gamma"),
}]);
let line = "- commit 0123456 asks for a release under scope `gamma`";
let body = render_comment(&state).expect("a dropped release is worth saying");
assert!(body.contains(line), "{body}");
assert!(render_summary(&state).contains(line), "{state:?}");
}
#[test]
fn a_package_awaiting_its_tag_reaches_both_renders() {
let state = empty_state(RenderTarget::Comment, CoverageOutcome::NotAsked)
.with_awaiting_tag(vec![cargo("alpha")]);
let body = render_comment(&state).expect("a pending tag is worth saying");
assert!(
body.contains("Released, awaiting its tag:\n\n- `alpha` (cargo)"),
"{body}"
);
assert!(
render_summary(&state).contains("Released, awaiting its tag: alpha (`cargo`)"),
"{state:?}"
);
}
#[test]
fn a_release_made_only_of_dependency_updates_says_so_in_both_renders() {
let state: ReleaseState = serde_json::from_str(
r#"{"schema_version":1,"target":"comment","uncovered":[],"packages":[
{"name":"app","ecosystem":"cargo","from":"0.1.0","to":"0.1.1","bump":"patch","source":{"kind":"dependency-update"}}]}"#,
)
.expect("state");
let body = render_comment(&state).expect("a release is worth saying");
assert!(
body.contains("- `app` 0.1.0 → 0.1.1 (patch, dependency updates)"),
"{body}"
);
assert!(
render_summary(&state).contains("| patch | dependency updates |"),
"{state:?}"
);
}
#[test]
fn a_unread_package_reaches_both_renders() {
let state = empty_state(RenderTarget::Comment, CoverageOutcome::NotAsked)
.with_updates_unread(vec![cargo("alpha")]);
let body = render_comment(&state).expect("an unread package is worth saying");
assert!(
body.contains("Dependency updates not read:\n\n- `alpha` (cargo)"),
"{body}"
);
assert!(
render_summary(&state).contains("Dependency updates not read: alpha (`cargo`)"),
"{state:?}"
);
}
#[test]
fn a_hand_set_version_reaches_both_renders_before_the_release() {
let planned: ReleaseState = serde_json::from_str(
r#"{"schema_version":1,"target":"comment","uncovered":[],
"packages":[{"name":"demo","ecosystem":"cargo","from":"0.1.1","to":"0.1.2",
"bump":"patch","source":{"kind":"intent"}}]}"#,
)
.expect("state");
let state = planned.with_hand_set(vec![HandSet::new(
cargo("demo"),
Version::new(0, 1, 1),
String::from("demo (cargo): tag it"),
)]);
let body = render_comment(&state).expect("a block is worth saying");
let block = body.find("- demo (cargo): tag it").expect(&body);
assert!(
block < body.find("These packages will release").expect(&body),
"{body}"
);
assert!(
render_summary(&state).contains("version set by hand; `oakum version` refuses this plan until each is fixed:\n\n- demo (cargo): tag it"),
"{state:?}"
);
}
#[test]
fn a_comment_with_nothing_to_say_is_none() {
let quiet = empty_state(
RenderTarget::Comment,
CoverageOutcome::Ran(Coverage::default()),
);
assert_eq!(render_comment(&quiet), None);
}
#[test]
fn a_failed_coverage_look_is_named_in_both_renders() {
let failed = empty_state(RenderTarget::Comment, CoverageOutcome::Failed);
let body = render_comment(&failed).expect("a failed look is worth saying");
assert!(body.contains("Coverage was not checked"), "{body}");
assert!(
render_summary(&empty_state(RenderTarget::Summary, CoverageOutcome::Failed))
.contains("Coverage was not checked")
);
}
#[test]
fn a_look_nobody_asked_for_is_not_reported_as_a_failure() {
let summary = render_summary(&empty_state(
RenderTarget::Status,
CoverageOutcome::NotAsked,
));
assert!(
!summary.contains("Coverage was not checked"),
"nothing asked, so nothing failed: {summary}"
);
}
#[test]
fn a_config_that_manages_nothing_is_named_in_both_renders() {
let state = empty_state(
RenderTarget::Comment,
CoverageOutcome::Ran(Coverage::default()),
)
.managing_nothing();
let body = render_comment(&state).expect("a config that can never release is worth saying");
assert!(body.contains("manages no package on either axis"), "{body}");
let summary = empty_state(
RenderTarget::Summary,
CoverageOutcome::Ran(Coverage::default()),
)
.managing_nothing();
assert!(render_summary(&summary).contains("manages no package on either axis"));
}
#[test]
fn an_emptied_selection_is_named_in_both_renders() {
let summary = render_summary(
&empty_state(RenderTarget::Status, CoverageOutcome::NotAsked).selection_emptied(),
);
assert!(
summary.contains("`include`/`exclude` leave no package selected"),
"{summary}"
);
assert!(
summary.contains("`check` does not refuse this"),
"the divergence is the point: {summary}"
);
let comment = render_comment(
&empty_state(RenderTarget::Comment, CoverageOutcome::NotAsked).selection_emptied(),
)
.expect("an emptied selection is worth a comment");
assert!(
comment.contains("`include`/`exclude` leave no package selected"),
"{comment}"
);
}
}