581 lines
21 KiB
Rust
581 lines
21 KiB
Rust
|
//! The inspector: one seat's whole picture, rendered as text
|
||
|
|
//! (CB-WP-0011 T01).
|
||
|
|
//!
|
||
|
|
//! Moved out of `table.rs`, where it was born in stage 0 as a prompt
|
||
|
|
//! header. That is exactly what was wrong with it: written to show a
|
||
|
|
//! human their legal moves, it showed the six fields a chooser needs and
|
||
|
|
//! silently dropped the rest of the projection — the whole DARVO state
|
||
|
|
//! machine, the whole GROUND practice, the scoring mode, the Focus
|
||
|
|
//! tokens, the discard pile, and every part of the outcome except the
|
||
|
|
//! headline.
|
||
|
|
//!
|
||
|
|
//! **No test could have caught that**, which is the point worth writing
|
||
|
|
//! down. Every assertion a renderer test naturally makes — "the output
|
||
|
|
//! mentions round", "the output is non-empty", "P2's hand does not
|
||
|
|
//! appear" — is satisfied by a render that shows a third of the state.
|
||
|
|
//! The harness-does-nothing class, in its presentation form.
|
||
|
|
//!
|
||
|
|
//! So the renderer ships with [`tests::every_view_field_is_classified`],
|
||
|
|
//! which walks the *serialized shape* of `GroundView` and requires every
|
||
|
|
//! leaf path to be listed as either rendered or deliberately omitted. A
|
||
|
|
//! field added to the projection and forgotten here fails the build.
|
||
|
|
//!
|
||
|
|
//! **Stated non-goal, unchanged from stage 0:** no TUI, no colour, no
|
||
|
|
//! readline. This is the inspectable half of INTENT stage 1; the 2D half
|
||
|
|
//! needs a rendering port, which needs an ADR, which this pass does not
|
||
|
|
//! have (see the workplan's tier declaration).
|
||
|
|
|
||
|
|
use cb_kernel::PlayerId;
|
||
|
|
use games_ground::view::{GroundView, PlayerView, ProblemView, SelectionView};
|
||
|
|
|
||
|
|
pub fn suit_name(s: games_ground::Suit) -> &'static str {
|
||
|
|
match s {
|
||
|
|
games_ground::Suit::Clarify => "Clarify",
|
||
|
|
games_ground::Suit::Repair => "Repair",
|
||
|
|
games_ground::Suit::Boundary => "Boundary",
|
||
|
|
games_ground::Suit::Change => "Change",
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn seat_name(p: PlayerId) -> String {
|
||
|
|
format!("P{}", p.0 + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn cards(list: &[games_ground::SolutionCard]) -> String {
|
||
|
|
if list.is_empty() {
|
||
|
|
return "-".into();
|
||
|
|
}
|
||
|
|
list.iter()
|
||
|
|
.map(|c| suit_name(c.suit))
|
||
|
|
.collect::<Vec<_>>()
|
||
|
|
.join(", ")
|
||
|
|
}
|
||
|
|
|
||
|
|
/// GR-A11/A12: the sub-choice, with its argument. Rendered from the
|
||
|
|
/// variant rather than `{:?}` so the argument seat reads as `P3`, not
|
||
|
|
/// `PlayerId(2)` — the inspector speaks the table's vocabulary.
|
||
|
|
fn ground_choice(c: &games_ground::GroundChoice) -> String {
|
||
|
|
use games_ground::GroundChoice as G;
|
||
|
|
match c {
|
||
|
|
G::RestoreProblem { problem } => format!("restore [{problem}]"),
|
||
|
|
G::CancelAttack { attacker } => format!("cancel attack from {}", seat_name(*attacker)),
|
||
|
|
G::ProtectProblem { problem } => format!("protect [{problem}]"),
|
||
|
|
G::RemoveBlame { owner } => format!("remove blame from {}", seat_name(*owner)),
|
||
|
|
G::BreakRelation { with } => format!("break relation with {}", seat_name(*with)),
|
||
|
|
G::RejectReverse => "reject reverse".into(),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The per-seat social line: everything the seat has *declared* this
|
||
|
|
/// round, as opposed to what it *is*. Empty for a seat that has declared
|
||
|
|
/// nothing, so a quiet table stays readable.
|
||
|
|
fn render_declarations(id: PlayerId, view: &GroundView) -> String {
|
||
|
|
let mut parts: Vec<String> = Vec::new();
|
||
|
|
if let Some(target) = view.focus.get(&id) {
|
||
|
|
parts.push(format!("focus→{}", seat_name(*target)));
|
||
|
|
}
|
||
|
|
if let Some(mode) = view.ground_modes.get(&id) {
|
||
|
|
let name = match mode {
|
||
|
|
games_ground::GroundMode::Gr => "GR",
|
||
|
|
games_ground::GroundMode::Ou => "OU",
|
||
|
|
games_ground::GroundMode::Nd => "ND",
|
||
|
|
};
|
||
|
|
parts.push(format!("ground {name}"));
|
||
|
|
}
|
||
|
|
if let Some(choice) = view.ground_choices.get(&id) {
|
||
|
|
parts.push(ground_choice(choice));
|
||
|
|
}
|
||
|
|
if let Some(r) = view.support_responses.get(&id) {
|
||
|
|
parts.push(format!("support {r:?}"));
|
||
|
|
}
|
||
|
|
if let Some(t) = view.darvo_targets.get(&id) {
|
||
|
|
let mut bits: Vec<String> = Vec::new();
|
||
|
|
if let Some(p) = t.problem {
|
||
|
|
bits.push(format!("[{p}]"));
|
||
|
|
}
|
||
|
|
if let Some(p) = t.player {
|
||
|
|
bits.push(seat_name(p));
|
||
|
|
}
|
||
|
|
parts.push(format!(
|
||
|
|
"darvo target {}",
|
||
|
|
if bits.is_empty() {
|
||
|
|
"none".into()
|
||
|
|
} else {
|
||
|
|
bits.join(" ")
|
||
|
|
}
|
||
|
|
));
|
||
|
|
}
|
||
|
|
if parts.is_empty() {
|
||
|
|
String::new()
|
||
|
|
} else {
|
||
|
|
format!(" {}\n", parts.join(" "))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn render_player(id: PlayerId, p: &PlayerView, is_viewer: bool) -> String {
|
||
|
|
let hand = match &p.hand {
|
||
|
|
Some(list) => format!("hand [{}]", cards(list)),
|
||
|
|
None => format!("hand {} card(s)", p.hand_size),
|
||
|
|
};
|
||
|
|
format!(
|
||
|
|
" {}{} stress {} freedom {}{} darvo {:?} protect {} blame {} {hand}\n",
|
||
|
|
seat_name(id),
|
||
|
|
if is_viewer { " (you)" } else { " " },
|
||
|
|
p.stress,
|
||
|
|
if p.freedom_ready { "READY" } else { "SPENT" },
|
||
|
|
if p.freedom_gate_lifted {
|
||
|
|
" gate-lifted"
|
||
|
|
} else {
|
||
|
|
""
|
||
|
|
},
|
||
|
|
p.darvo,
|
||
|
|
p.protection,
|
||
|
|
p.blame_from.len(),
|
||
|
|
)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// One seat's whole picture, from the projection and nothing else.
|
||
|
|
pub fn render(view: &GroundView) -> String {
|
||
|
|
let mut out = String::new();
|
||
|
|
out.push_str(&format!(
|
||
|
|
"\nround {} step {:?} lead {} mode {:?} deck {} discard [{}]\n",
|
||
|
|
view.round,
|
||
|
|
view.step,
|
||
|
|
seat_name(view.lead),
|
||
|
|
view.mode,
|
||
|
|
view.solution_deck_len,
|
||
|
|
cards(&view.solution_discard),
|
||
|
|
));
|
||
|
|
for (id, p) in &view.players {
|
||
|
|
out.push_str(&render_player(*id, p, Some(*id) == view.viewer));
|
||
|
|
out.push_str(&render_declarations(*id, view));
|
||
|
|
}
|
||
|
|
|
||
|
|
out.push_str(" problems:");
|
||
|
|
for (priority, problem) in &view.problems {
|
||
|
|
match problem {
|
||
|
|
ProblemView::FaceDown => out.push_str(&format!(" [{priority}] face-down")),
|
||
|
|
ProblemView::FaceUp {
|
||
|
|
suit,
|
||
|
|
value,
|
||
|
|
denied,
|
||
|
|
claimed_by,
|
||
|
|
protected_this_round,
|
||
|
|
} => {
|
||
|
|
out.push_str(&format!(
|
||
|
|
" [{priority}] {} {}{}{}{}",
|
||
|
|
suit_name(*suit),
|
||
|
|
value,
|
||
|
|
if *denied { " DENIED" } else { "" },
|
||
|
|
if *protected_this_round {
|
||
|
|
" PROTECTED"
|
||
|
|
} else {
|
||
|
|
""
|
||
|
|
},
|
||
|
|
match claimed_by {
|
||
|
|
Some(p) => format!(" claimed by {}", seat_name(*p)),
|
||
|
|
None => String::new(),
|
||
|
|
}
|
||
|
|
));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
out.push('\n');
|
||
|
|
|
||
|
|
if !view.relations.is_empty() {
|
||
|
|
out.push_str(" relations:");
|
||
|
|
for (pair, relation) in &view.relations {
|
||
|
|
out.push_str(&format!(" {pair} {relation:?}"));
|
||
|
|
}
|
||
|
|
out.push('\n');
|
||
|
|
}
|
||
|
|
|
||
|
|
if !view.selections.is_empty() {
|
||
|
|
out.push_str(" selections:");
|
||
|
|
for (id, sel) in &view.selections {
|
||
|
|
match sel {
|
||
|
|
SelectionView::Hidden => out.push_str(&format!(" {} face-down", seat_name(*id))),
|
||
|
|
SelectionView::Shown(s) => out.push_str(&format!(
|
||
|
|
" {} {:?}{}{}",
|
||
|
|
seat_name(*id),
|
||
|
|
s.action,
|
||
|
|
match s.target {
|
||
|
|
Some(t) => format!("→{}", seat_name(t)),
|
||
|
|
None => String::new(),
|
||
|
|
},
|
||
|
|
match s.problem {
|
||
|
|
Some(p) => format!("→[{p}]"),
|
||
|
|
None => String::new(),
|
||
|
|
}
|
||
|
|
)),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
out.push('\n');
|
||
|
|
}
|
||
|
|
|
||
|
|
if let Some(o) = &view.outcome {
|
||
|
|
out.push_str(&format!(
|
||
|
|
" OUTCOME total {} / threshold {} group {}\n",
|
||
|
|
o.total,
|
||
|
|
o.threshold,
|
||
|
|
if o.group_success {
|
||
|
|
"SUCCESS"
|
||
|
|
} else {
|
||
|
|
"failure"
|
||
|
|
},
|
||
|
|
));
|
||
|
|
out.push_str(" personal:");
|
||
|
|
for (id, score) in &o.personal {
|
||
|
|
out.push_str(&format!(" {} {score}", seat_name(*id)));
|
||
|
|
}
|
||
|
|
out.push('\n');
|
||
|
|
if let Some(m) = o.mastery {
|
||
|
|
out.push_str(&format!(" mastery {m}\n"));
|
||
|
|
}
|
||
|
|
for c in &o.coalitions {
|
||
|
|
out.push_str(&format!(
|
||
|
|
" coalition [{}] score {}\n",
|
||
|
|
c.members
|
||
|
|
.iter()
|
||
|
|
.map(|m| seat_name(*m))
|
||
|
|
.collect::<Vec<_>>()
|
||
|
|
.join(", "),
|
||
|
|
c.score,
|
||
|
|
));
|
||
|
|
}
|
||
|
|
out.push_str(&format!(
|
||
|
|
" winners {}\n",
|
||
|
|
o.winners
|
||
|
|
.iter()
|
||
|
|
.map(|w| seat_name(*w))
|
||
|
|
.collect::<Vec<_>>()
|
||
|
|
.join(", "),
|
||
|
|
));
|
||
|
|
}
|
||
|
|
out
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
use games_ground::view::OutcomeView;
|
||
|
|
use games_ground::*;
|
||
|
|
use std::collections::BTreeMap;
|
||
|
|
|
||
|
|
/// Every leaf path in the serialized `GroundView`, with map keys and
|
||
|
|
/// array indices collapsed to `*`.
|
||
|
|
///
|
||
|
|
/// Paths, not keys: `problem` appears under a DARVO target, a GROUND
|
||
|
|
/// choice and a Selection, and a key-set walk would let one of the
|
||
|
|
/// three vouch for the other two.
|
||
|
|
fn paths(v: &serde_json::Value, prefix: &str, out: &mut Vec<String>) {
|
||
|
|
match v {
|
||
|
|
serde_json::Value::Object(map) => {
|
||
|
|
for (k, child) in map {
|
||
|
|
let next = if prefix.is_empty() {
|
||
|
|
k.clone()
|
||
|
|
} else {
|
||
|
|
format!("{prefix}.{k}")
|
||
|
|
};
|
||
|
|
paths(child, &next, out);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
serde_json::Value::Array(items) => {
|
||
|
|
for item in items {
|
||
|
|
paths(item, &format!("{prefix}.*"), out);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_ => out.push(prefix.to_string()),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// A `BTreeMap` serializes as an object, so its *keys* look like
|
||
|
|
/// struct fields. Collapse any path segment that is a map key —
|
||
|
|
/// seat names, Problem priorities, `Pair` keys — to `*`.
|
||
|
|
fn normalize(path: &str) -> String {
|
||
|
|
let maps = [
|
||
|
|
"players",
|
||
|
|
"relations",
|
||
|
|
"problems",
|
||
|
|
"focus",
|
||
|
|
"selections",
|
||
|
|
"ground_modes",
|
||
|
|
"ground_choices",
|
||
|
|
"support_responses",
|
||
|
|
"darvo_targets",
|
||
|
|
"personal",
|
||
|
|
];
|
||
|
|
let mut parts: Vec<String> = Vec::new();
|
||
|
|
let mut collapse_next = false;
|
||
|
|
for seg in path.split('.') {
|
||
|
|
if collapse_next {
|
||
|
|
parts.push("*".into());
|
||
|
|
collapse_next = false;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
parts.push(seg.to_string());
|
||
|
|
collapse_next = maps.contains(&seg);
|
||
|
|
}
|
||
|
|
parts.join(".")
|
||
|
|
}
|
||
|
|
|
||
|
|
/// What the inspector shows, and the token that proves it does. The
|
||
|
|
/// token is asserted against the fixture's output — delete a field
|
||
|
|
/// from `render` and its row goes red naming the field.
|
||
|
|
const RENDERED: &[(&str, &str)] = &[
|
||
|
|
("round", "round 3"),
|
||
|
|
("step", "step Resolve"),
|
||
|
|
("lead", "lead P2"),
|
||
|
|
("mode", "mode BondedCoalitions"),
|
||
|
|
("viewer", "(you)"),
|
||
|
|
("solution_deck_len", "deck 11"),
|
||
|
|
("solution_discard.*.suit", "discard [Repair, Change]"),
|
||
|
|
("players.*.stress", "stress 4"),
|
||
|
|
("players.*.freedom_ready", "freedom SPENT"),
|
||
|
|
("players.*.freedom_gate_lifted", "gate-lifted"),
|
||
|
|
("players.*.darvo", "darvo Attack"),
|
||
|
|
("players.*.protection", "protect 2"),
|
||
|
|
("players.*.blame_from.*", "blame 2"),
|
||
|
|
("players.*.hand.*.suit", "hand [Clarify, Boundary]"),
|
||
|
|
("players.*.hand_size", "hand 4 card(s)"),
|
||
|
|
("relations.*", "Rivalry"),
|
||
|
|
("problems.*.state", "face-down"),
|
||
|
|
("problems.*.suit", "Boundary"),
|
||
|
|
("problems.*.value", "Boundary 9"),
|
||
|
|
("problems.*.denied", "DENIED"),
|
||
|
|
("problems.*.protected_this_round", "PROTECTED"),
|
||
|
|
("problems.*.claimed_by", "claimed by P3"),
|
||
|
|
("focus.*", "focus→P3"),
|
||
|
|
("ground_modes.*", "ground OU"),
|
||
|
|
("ground_choices.*.choice", "cancel attack from"),
|
||
|
|
("ground_choices.*.attacker", "cancel attack from P2"),
|
||
|
|
("support_responses.*", "support FlipToBond"),
|
||
|
|
("darvo_targets.*.problem", "darvo target [7]"),
|
||
|
|
("darvo_targets.*.player", "darvo target [7] P1"),
|
||
|
|
("selections.*.state", "face-down"),
|
||
|
|
("selections.*.action", "Investigate"),
|
||
|
|
("selections.*.target", "Investigate→P2"),
|
||
|
|
("selections.*.problem", "→[7]"),
|
||
|
|
("outcome.total", "total 18"),
|
||
|
|
("outcome.threshold", "threshold 15"),
|
||
|
|
("outcome.group_success", "group SUCCESS"),
|
||
|
|
("outcome.personal.*", "P1 6"),
|
||
|
|
("outcome.mastery", "mastery 3"),
|
||
|
|
("outcome.coalitions.*.members.*", "coalition [P1, P2]"),
|
||
|
|
("outcome.coalitions.*.score", "score 11"),
|
||
|
|
("outcome.winners.*", "winners P1, P2"),
|
||
|
|
];
|
||
|
|
|
||
|
|
/// Deliberately not shown, each with the reason.
|
||
|
|
///
|
||
|
|
/// **This list is an unchecked claim**, and saying so is cheaper than
|
||
|
|
/// pretending otherwise: the test proves a `RENDERED` row is really
|
||
|
|
/// rendered, and proves nothing about an `OMITTED` one. What it does
|
||
|
|
/// enforce is that the claim was *made* — a new field cannot arrive
|
||
|
|
/// silently in either list.
|
||
|
|
const OMITTED: &[(&str, &str)] = &[
|
||
|
|
// `viewer: null` is a spectator, rendered by the *absence* of
|
||
|
|
// "(you)" — there is no token for it, and adding one would mean
|
||
|
|
// printing a line that says nothing.
|
||
|
|
// `null` for every seat but the viewer — GR-S02. There is no
|
||
|
|
// content to show, and the absence is exactly what the count
|
||
|
|
// form (`hand 4 card(s)`) renders. A token here would assert
|
||
|
|
// that the inspector prints something about a thing it must not
|
||
|
|
// print anything about.
|
||
|
|
(
|
||
|
|
"players.*.hand",
|
||
|
|
"null for a non-viewer seat; the absence is rendered as a count",
|
||
|
|
),
|
||
|
|
];
|
||
|
|
|
||
|
|
/// Round 3, mid-DARVO, mid-GROUND, scored. Built by hand rather than
|
||
|
|
/// played: at deal time two thirds of these fields are empty, and a
|
||
|
|
/// coverage test run against absent fields is the same lie in a
|
||
|
|
/// different costume.
|
||
|
|
fn fixture() -> GroundView {
|
||
|
|
let (p1, p2, p3) = (PlayerId(0), PlayerId(1), PlayerId(2));
|
||
|
|
let card = |suit| SolutionCard { suit };
|
||
|
|
let mut players = BTreeMap::new();
|
||
|
|
players.insert(
|
||
|
|
p1,
|
||
|
|
PlayerView {
|
||
|
|
stress: 4,
|
||
|
|
freedom_ready: false,
|
||
|
|
freedom_gate_lifted: true,
|
||
|
|
darvo: DarvoStage::Attack,
|
||
|
|
protection: 2,
|
||
|
|
blame_from: vec![p2, p3],
|
||
|
|
hand: Some(vec![card(Suit::Clarify), card(Suit::Boundary)]),
|
||
|
|
hand_size: 2,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
for (id, stress) in [(p2, 1u8), (p3, 0)] {
|
||
|
|
players.insert(
|
||
|
|
id,
|
||
|
|
PlayerView {
|
||
|
|
stress,
|
||
|
|
freedom_ready: true,
|
||
|
|
freedom_gate_lifted: false,
|
||
|
|
darvo: DarvoStage::Off,
|
||
|
|
protection: 0,
|
||
|
|
blame_from: vec![],
|
||
|
|
hand: None,
|
||
|
|
hand_size: 4,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
let mut problems = BTreeMap::new();
|
||
|
|
problems.insert(1, ProblemView::FaceDown);
|
||
|
|
problems.insert(
|
||
|
|
7,
|
||
|
|
ProblemView::FaceUp {
|
||
|
|
suit: Suit::Boundary,
|
||
|
|
value: 9,
|
||
|
|
denied: true,
|
||
|
|
claimed_by: Some(p3),
|
||
|
|
protected_this_round: true,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
|
||
|
|
GroundView {
|
||
|
|
viewer: Some(p1),
|
||
|
|
round: 3,
|
||
|
|
lead: p2,
|
||
|
|
step: RoundStep::Resolve,
|
||
|
|
mode: ScoringMode::BondedCoalitions,
|
||
|
|
players,
|
||
|
|
relations: BTreeMap::from([
|
||
|
|
(Pair::new(p1, p2), Relation::Bond),
|
||
|
|
(Pair::new(p2, p3), Relation::Rivalry),
|
||
|
|
]),
|
||
|
|
problems,
|
||
|
|
focus: BTreeMap::from([(p1, p3)]),
|
||
|
|
selections: BTreeMap::from([
|
||
|
|
(
|
||
|
|
p1,
|
||
|
|
SelectionView::Shown(Selection {
|
||
|
|
action: Action::Investigate,
|
||
|
|
target: Some(p2),
|
||
|
|
problem: Some(7),
|
||
|
|
}),
|
||
|
|
),
|
||
|
|
(p2, SelectionView::Hidden),
|
||
|
|
]),
|
||
|
|
ground_modes: BTreeMap::from([(p1, GroundMode::Ou)]),
|
||
|
|
ground_choices: BTreeMap::from([(p1, GroundChoice::CancelAttack { attacker: p2 })]),
|
||
|
|
support_responses: BTreeMap::from([(p2, SupportResponse::FlipToBond)]),
|
||
|
|
darvo_targets: BTreeMap::from([(
|
||
|
|
p1,
|
||
|
|
DarvoTarget {
|
||
|
|
problem: Some(7),
|
||
|
|
player: Some(p1),
|
||
|
|
},
|
||
|
|
)]),
|
||
|
|
solution_deck_len: 11,
|
||
|
|
solution_discard: vec![card(Suit::Repair), card(Suit::Change)],
|
||
|
|
outcome: Some(OutcomeView {
|
||
|
|
total: 18,
|
||
|
|
threshold: 15,
|
||
|
|
group_success: true,
|
||
|
|
personal: BTreeMap::from([(p1, 6), (p2, 5), (p3, 7)]),
|
||
|
|
coalitions: vec![Coalition {
|
||
|
|
members: vec![p1, p2],
|
||
|
|
score: 11,
|
||
|
|
}],
|
||
|
|
mastery: Some(3),
|
||
|
|
winners: vec![p1, p2],
|
||
|
|
}),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn fixture_paths() -> Vec<String> {
|
||
|
|
let json = serde_json::to_value(fixture()).expect("view serializes");
|
||
|
|
let mut raw = Vec::new();
|
||
|
|
paths(&json, "", &mut raw);
|
||
|
|
let mut all: Vec<String> = raw.iter().map(|p| normalize(p)).collect();
|
||
|
|
all.sort();
|
||
|
|
all.dedup();
|
||
|
|
all
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The gate: every field the projection carries is classified, and
|
||
|
|
/// every field claimed rendered really is.
|
||
|
|
#[test]
|
||
|
|
fn every_view_field_is_classified() {
|
||
|
|
let out = render(&fixture());
|
||
|
|
let all = fixture_paths();
|
||
|
|
|
||
|
|
// EXPECT-VACUOUS control. A coverage test over an empty path set
|
||
|
|
// passes trivially, and that is precisely how this check would
|
||
|
|
// rot — a serde change, a flattened field, a walk that stops at
|
||
|
|
// the first map. `GroundView` has 17 fields and the fixture
|
||
|
|
// populates all of them; 30 leaves is a floor, not a count, so
|
||
|
|
// adding a field never fails this line for the wrong reason.
|
||
|
|
assert!(
|
||
|
|
all.len() >= 30,
|
||
|
|
"the walk found {} leaf path(s) — it is not walking the view",
|
||
|
|
all.len()
|
||
|
|
);
|
||
|
|
|
||
|
|
let rendered: Vec<&str> = RENDERED.iter().map(|(p, _)| *p).collect();
|
||
|
|
let omitted: Vec<&str> = OMITTED.iter().map(|(p, _)| *p).collect();
|
||
|
|
|
||
|
|
let unclassified: Vec<&String> = all
|
||
|
|
.iter()
|
||
|
|
.filter(|p| !rendered.contains(&p.as_str()) && !omitted.contains(&p.as_str()))
|
||
|
|
.collect();
|
||
|
|
assert!(
|
||
|
|
unclassified.is_empty(),
|
||
|
|
"new field(s) in GroundView are neither rendered nor declared omitted: {unclassified:?}\n\
|
||
|
|
add each to RENDERED (with a token the inspector prints) or to OMITTED (with a reason)"
|
||
|
|
);
|
||
|
|
|
||
|
|
let stale: Vec<&str> = rendered
|
||
|
|
.iter()
|
||
|
|
.chain(omitted.iter())
|
||
|
|
.filter(|p| !all.contains(&p.to_string()))
|
||
|
|
.copied()
|
||
|
|
.collect();
|
||
|
|
assert!(
|
||
|
|
stale.is_empty(),
|
||
|
|
"classified path(s) no longer exist in GroundView: {stale:?}"
|
||
|
|
);
|
||
|
|
|
||
|
|
for (path, token) in RENDERED {
|
||
|
|
assert!(
|
||
|
|
out.contains(token),
|
||
|
|
"{path} is claimed rendered, but the output has no {token:?}\n--- output ---\n{out}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The projection decides what is visible; the inspector must not
|
||
|
|
/// widen it. P1 is the viewer, so P2's and P3's hands are `None` and
|
||
|
|
/// only their sizes may appear.
|
||
|
|
#[test]
|
||
|
|
fn the_inspector_never_widens_the_projection() {
|
||
|
|
let out = render(&fixture());
|
||
|
|
assert!(out.contains("hand [Clarify, Boundary]"), "{out}");
|
||
|
|
assert_eq!(
|
||
|
|
out.matches("hand 4 card(s)").count(),
|
||
|
|
2,
|
||
|
|
"both non-viewer seats show a count and nothing more\n{out}"
|
||
|
|
);
|
||
|
|
// P2 selected face-down; the tag carries no Selection to leak,
|
||
|
|
// and the render must not invent one.
|
||
|
|
assert!(out.contains("P2 face-down"), "{out}");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// A spectator sees no hand at all and is not told they are anyone.
|
||
|
|
#[test]
|
||
|
|
fn a_spectator_view_renders_without_a_seat() {
|
||
|
|
let mut view = fixture();
|
||
|
|
view.viewer = None;
|
||
|
|
view.players.get_mut(&PlayerId(0)).unwrap().hand = None;
|
||
|
|
let out = render(&view);
|
||
|
|
assert!(!out.contains("(you)"), "{out}");
|
||
|
|
assert!(!out.contains("hand ["), "{out}");
|
||
|
|
}
|
||
|
|
}
|