wsb 0.258.6441

Workspace tools for every project under $PRJ: git across submodules, template stamping, GitHub, and the workbench
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

//! What the parity document says, and what it must never say.
//!
//! Built on an in-memory catalogue rather than the workspace's. The workspace
//! changes every time anybody writes a test, so a test that read it would
//! assert whatever happened to be true this afternoon — and the properties
//! worth pinning are properties of the RENDERING, which a fixture states
//! exactly.

use super::*;
use crate::persist::local::models::catalogued_test::TestLanguage;
use std::sync::Arc;

const MEMBERS: [&str; 3] = ["family/one", "family/two", "family/three"];

fn members() -> Vec<String> {
    MEMBERS.iter().map(|m| m.to_string()).collect()
}

fn test(repo: &str, number: i64, name: &str, description: &str) -> CataloguedTest {
    CataloguedTest {
        id: format!("{repo}:{name}"),
        repo: repo.to_string(),
        language: TestLanguage::Rust,
        number: Some(number),
        function_name: name.to_string(),
        description: description.to_string(),
        // A row per line: the table keys on repo + file + line, which is the
        // right key — two tests cannot share a line — and a fixture that
        // ignored it would be writing rows the real scanner never produces.
        file_path: "src/lib.rs".to_string(),
        line_number: number,
        feature_id: None,
    }
}

/// A catalogue holding exactly what a test puts in it.
fn catalogue(rows: &[CataloguedTest]) -> CatalogueRepo {
    let service = crate::persist::local::database::initialize_database_in_memory()
        .expect("an in-memory database");
    service.run_migrations(crate::persist::global::Schema::Worktree).expect("the schema is created");
    let repo = CatalogueRepo::new(Arc::new(service));
    for member in MEMBERS {
        let owned: Vec<CataloguedTest> = rows
            .iter()
            .filter(|row| row.repo == member)
            .cloned()
            .collect();
        repo.replace_repo(member, &owned).expect("the rows are written");
    }
    repo
}

/// TEST11254: a number missing from a mirror is reported as a gap, and one
/// present everywhere is not.
///
/// The whole claim of the document. Five implementations of one protocol are
/// one protocol only while the same number means the same thing in each, and
/// this report is the only thing that says where that stopped being true — so a
/// report that missed a gap, or invented one, is worse than none.
#[test]
fn test11254_a_number_missing_from_a_mirror_is_reported_as_a_gap() {
    let rows = vec![
        test("family/one", 100, "test0100_everywhere", "everywhere"),
        test("family/two", 100, "test0100_everywhere", "everywhere"),
        test("family/three", 100, "test0100_everywhere", "everywhere"),
        test("family/one", 200, "test0200_only_here", "only here"),
        test("family/two", 200, "test0200_only_here", "only here"),
    ];
    let document = parity_markdown(&catalogue(&rows), &members()).expect("the report renders");

    let gaps = section(&document, "## Parity gaps");
    assert!(
        gaps.contains("TEST200") && gaps.contains("three"),
        "the gap must be reported, and must name the mirror it is missing from:\n{gaps}"
    );
    assert!(
        !gaps.contains("TEST100"),
        "a number every mirror has is not a gap:\n{gaps}"
    );
    assert!(
        document.contains("- Shared numbers with a parity gap (missing from ≥1 mirror): **1**"),
        "the summary must agree with the table:\n{document}"
    );
}

/// TEST11255: a number one mirror alone claims is a port target below 8000 and
/// nothing to answer for at or above it.
///
/// The range is the whole reason a solo test is sometimes a backlog item and
/// sometimes correct. A report that did not tell them apart would put every
/// implementation-specific test on the port worklist, which is how the previous
/// one came to list hundreds of entries nobody could act on.
#[test]
fn test11255_the_shared_range_decides_whether_a_solo_test_is_a_backlog_item() {
    let rows = vec![
        test("family/one", 300, "test0300_shared_range_solo", "ports to the others"),
        test("family/one", 8300, "test8300_impl_specific", "this mirror's own"),
    ];
    let document = parity_markdown(&catalogue(&rows), &members()).expect("the report renders");

    let worklist = section(&document, "## Solo tests in the shared range");
    assert!(
        worklist.contains("TEST300"),
        "a solo test below the ceiling is a port target:\n{worklist}"
    );
    assert!(
        !worklist.contains("TEST8300"),
        "a solo test at or above the ceiling is correctly placed, not a backlog item:\n{worklist}"
    );
    assert!(
        section(&document, "## Parity gaps").lines().all(|l| !l.contains("TEST8300")),
        "an implementation-specific number is not a parity gap:\n{document}"
    );
}

/// TEST11256: two mirrors describing one number differently are shown side by
/// side, and identical wording is not.
///
/// This is the check that catches "same number, different test" — the one
/// failure the number scheme cannot survive. It has to ignore wording that
/// differs only in whitespace, or the section fills with noise and stops being
/// read, which is what happened to its predecessor.
#[test]
fn test11256_divergent_descriptions_are_shown_and_whitespace_is_not_divergence() {
    let rows = vec![
        test("family/one", 400, "test0400_a", "the parser rejects an empty header"),
        test("family/two", 400, "test0400_a", "the parser  rejects an empty\nheader"),
        test("family/one", 500, "test0500_b", "a cap resolves to its alias"),
        test("family/two", 500, "test0500_b", "a media resolves to its alias"),
    ];
    let document = parity_markdown(&catalogue(&rows), &members()).expect("the report renders");

    let divergent = section(&document, "## Divergent descriptions");
    assert!(
        divergent.contains("### TEST500"),
        "two mirrors describing one number differently must be shown:\n{divergent}"
    );
    assert!(
        divergent.contains("a cap resolves to its alias")
            && divergent.contains("a media resolves to its alias"),
        "and shown side by side, because that is the only way to judge them:\n{divergent}"
    );
    assert!(
        !divergent.contains("### TEST400"),
        "the same sentence wrapped differently is not a divergence:\n{divergent}"
    );
}

/// TEST11257: a description does not break the table it is written into.
///
/// Descriptions are doc comments. They carry newlines, leading `///` and pipe
/// characters, and each of those ends a markdown row early — silently, so the
/// document renders as a table that has quietly lost its remaining columns.
#[test]
fn test11257_a_description_cannot_break_the_row_it_is_written_into() {
    let rows = vec![test(
        "family/one",
        600,
        "test0600_awkward",
        "/// a | b\n/// and a second line",
    )];
    let document = parity_markdown(&catalogue(&rows), &members()).expect("the report renders");

    let row = document
        .lines()
        .find(|line| line.contains("TEST600"))
        .expect("the solo test is listed")
        .to_string();
    assert!(
        !row.contains("\\n"),
        "the description must be flattened onto the row: {row}"
    );
    assert_eq!(
        row.matches(" | ").count(),
        4,
        "a five-column row has four separators; an unescaped pipe adds one: {row}"
    );
    assert!(
        row.contains("a \\| b"),
        "a pipe in the description must be escaped, not dropped: {row}"
    );
}

/// TEST11258: the document never names the private tool that wrote it.
///
/// It is written into `capdag/docs/`, and the capdag mirrors are PUBLIC on
/// GitHub. A generated header naming the tool puts that name in a public
/// repository, which is the one thing this workspace's publishing rules forbid
/// outright.
#[test]
fn test11258_the_parity_document_does_not_name_the_private_tool() {
    let rows = vec![test("family/one", 700, "test0700_a", "something")];
    let document = parity_markdown(&catalogue(&rows), &members()).expect("the report renders");
    let tool = concat!("sd", "x");
    assert!(
        !document.to_lowercase().contains(tool),
        "the document names the private tool:\n{document}"
    );
}

/// One `##` section of the document, up to the next one.
fn section<'a>(document: &'a str, heading: &str) -> &'a str {
    let start = document
        .find(heading)
        .unwrap_or_else(|| panic!("the document has no '{heading}' section:\n{document}"));
    let rest = &document[start + heading.len()..];
    match rest.find("\n## ") {
        Some(end) => &rest[..end],
        None => rest,
    }
}