cardgen

var Ledgers = map[string]Ledger{
	"serial-tests": {
		Name: "serial-tests", File: "internal/ci/testdata/serial-tests_allowlist.txt", Test: "internal/ci TestEveryTestOpensWithTParallel", Tier: "flash",
		Task: "The ledger {{ledger}} lists {{count}} test(s) of {{file}} that do not open with t.Parallel(): {{rows}}. Each row's reason names what makes the test unsafe beside another (t.Setenv, t.Chdir, os.Setenv, os.Chdir, a swapped package variable). Delete those rows from the ledger first, so {{test}} goes red naming each test; then make every one of those tests open with t.Parallel() as its first statement by giving it a per-test seam in place of the process-wide call: cmd.Env on the command it runs instead of t.Setenv, a directory argument or t.TempDir instead of t.Chdir, an injected value instead of a package-level swap. The test's assertions stay as they are; only the seam changes. A test that cannot be made safe this way is reported, with its row left in place, as not done." + ceilingNote + draftRule,
		Parse: func(line string) (Row, bool) {
			m := colonRowRE.FindStringSubmatch(line)
			if m == nil {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[2], Rest: m[3]}, true
		},
	},
	"slowwaits": {
		Name: "slowwaits", File: "internal/ci/testdata/slowwaits_allowlist.txt", Test: "internal/ci TestNoTestSleepsOverASecondOrWaitsOutADeadlineOverFive", Tier: "flash",
		Task: "The ledger {{ledger}} lists {{count}} test(s) of {{file}} that still write a sleep over one second or a deadline between five and thirty seconds: {{rows}}. Delete those rows from the ledger first, so {{test}} goes red naming each test; then give each test a bound under the rule's limit, or route its wait through the package's clock seam, keeping the assertion it makes. A test that waits a deadline out belongs behind the slow tag, and that move is reported, not made here." + draftRule,
		Parse: func(line string) (Row, bool) {
			m := colonRowRE.FindStringSubmatch(line)
			if m == nil {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[2], Rest: m[3]}, true
		},
	},
	"sleeps-skips": {
		Name: "sleeps-skips", File: "internal/ci/sleeps-skips_allowlist.txt", Test: "internal/ci TestNoUnitTestWaitsOnTheWallClock", Tier: "flash",
		Task: "The SLEEPS ledger {{ledger}} lists {{count}} unit test(s) of the package {{file}} that wait on the wall clock, or skip themselves with t.Skip(\"SLEEPS: ...\"): {{rows}}. Delete those rows from the ledger first, so {{test}} goes red naming each one; then make each test wait on no real time: an injected clock, testing/synctest, or a signal from the code under test in place of time.Sleep, time.After and a wall-clock deadline (docs/TESTING.md: unit tests use no real time). A test that needs real time is a functional test and moves behind the functional tag, which is reported." + draftRule,
		Parse: func(line string) (Row, bool) {
			f := strings.Split(line, "\t")
			if len(f) < 2 || f[0] == "" || f[1] == "" {
				return Row{}, false
			}
			return Row{File: f[0], Key: f[1], Rest: strings.Join(f[2:], " ")}, true
		},
	},
	"fixed-waits": {
		Name: "fixed-waits", File: "internal/ci/testdata/fixed-waits-allowlist.txt", Test: "internal/ci TestNoFixedWaitsOnTheCIPath", Tier: "flash",
		Task: "The ledger {{ledger}} lists {{count}} fixed wait(s) in {{file}}: {{rows}} (file:line, the kind of wait, the date, the reason). Delete those rows from the ledger first, so {{test}} goes red naming each site; then replace each wait: a fixed sleep becomes a poll on the condition it waited for, a short bound becomes one the code under test is handed, an elapsed-time assertion becomes an assertion on what happened. The allowlist only shrinks: a row that names no offender is refused by the test." + draftRule,
		Parse: func(line string) (Row, bool) {
			m := lineRowRE.FindStringSubmatch(line)
			if m == nil {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[2], Rest: m[3]}, true
		},
	},
	"dead-code": {
		Name: "dead-code", File: "internal/ci/testdata/dead_code_allowlist.txt", Test: "internal/ci TestDeadCode", Tier: "pro", Counted: true,
		Task: "The dead code ledger {{ledger}} carries the row `{{rows}}`: the package {{file}} has that many functions unreachable from any cmd/ root (the union over GOOS linux, darwin and windows). Run the class test {{test}} to read the names the deadcode tool reports for the package; delete each unreachable function with its tests and any helper only it used, then lower the package's count on its ledger row (to zero deletes the row) so {{test}} is green with fewer rows. A function that is reachable on one GOOS only is not dead and stays." + ceilingNote + draftRule,
		Parse: func(line string) (Row, bool) {
			m := countRowRE.FindStringSubmatch(line)
			if m == nil {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[2], Rest: m[2]}, true
		},
	},
	"namedpaths": {
		Name: "namedpaths", File: "internal/ci/testdata/namedpaths_allowlist.txt", Test: "internal/ci TestEveryNamedRepoPathExists", Tier: "pro",
		Task: "The ledger {{ledger}} carries the row `{{rows}}`: the name {{file}} looks like a path into this repository and is not one, and the row says why. Find what writes the name (grep the tree for it), then either make the name true (create the file the sentence promises, or point the sentence at the file that exists) or reword the sentence so it names no path; then delete the row, so {{test}} is green with one row fewer. The list is checked in both directions: a stale row is as red as a missing one." + draftRule,
		Parse: func(line string) (Row, bool) {
			m := firstWordRE.FindStringSubmatch(line)
			if m == nil {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[1], Rest: m[2]}, true
		},
	},
	"transcripts": {
		Name: "transcripts", File: "internal/ci/testdata/transcripts_allowlist.txt", Test: "internal/ci TestEveryTranscriptIsExecutedLineForLine", Tier: "pro",
		Task: "The ledger {{ledger}} carries the row `{{rows}}`: the `## {{file}}` section of docs/TESTS.md is executed by no test line for line through onboarding.CompareTranscript (docs/SPEC-TOOLWORK.md rule 3). Delete the row first, so {{test}} goes red naming the section; then write the test in cmd/{{file}} that runs the section's transcript line by line through onboarding.CompareTranscript, correcting the transcript where the tool's output has moved on, so the test is green. The list only shrinks." + draftRule,
		Parse: func(line string) (Row, bool) {
			m := transcriptRowRE.FindStringSubmatch(line)
			if m == nil || m[1] == "" {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[1], Rest: strings.TrimSpace(m[2])}, true
		},
	},
	"generality-fixtures": {
		Name: "generality-fixtures", File: "internal/ci/testdata/generality_text_fixtures_allowlist.txt", Test: "internal/ci TestGeneralityText", Tier: "pro", Generated: true,
		Task: "The ledger {{ledger}} carries the row `{{rows}}`: the whole file {{file}} is excepted from the generality scan because it carries fleet, person or host names as recorded data. Decide whether it still must: a synthetic fixture is rewritten with generic names and its row deleted; a true recording keeps its row and this card reports not-done with the reason. Run {{test}} with NOVA_CI_UPDATE=1 once after the change and commit what it writes; this ledger is a generated one land regenerates on a conflict." + draftRule,
		Parse: func(line string) (Row, bool) {
			m := firstWordRE.FindStringSubmatch(line)
			if m == nil {
				return Row{}, false
			}
			return Row{File: m[1], Key: m[1], Rest: m[2]}, true
		},
	},
}