**Commit Check failed**
>
-> ❌ **2 of 4 checks failed**
+> 
Pull request: passed
Commits: 1 of 2 failed
-> ():
+> - Branch: change "Feature/Add-Login" to "feature/Add-Login"
+> ```
+>
+> **Commit messages.** Reword it, then force-push:
+>
+> ```bash
+> git commit --amend
+> git push --force-with-lease
+> ```
+>
+> **Branch name.** Rename the branch and push it. A pull request cannot change its branch, so open a new one from the renamed branch:
+>
+> ```bash
+> git branch -m feature/Add-Login
+> git push -u origin HEAD
+> ```
+>
+> **Next time.** The [pre-commit hook](https://commit-check.com/guides/integrations/#as-a-pre-commit-hook) runs the same rules before you push.
+>
+>
+>
+> Show all 4 checks
+>How to fix
+> +> **With an AI coding agent.** Paste this prompt: +> +> ```text +> Fix these Commit Check findings without changing any code: +> - Commit 5584f46 "bad msg": Use
+> ():
> Branch
-> ✖ Branch (1 failure)
+> ✖ branch Feature/Add-Login
> CC201 branch
> value: Feature/Add-Login
> The branch should follow Conventional Branch.
@@ -150,36 +188,28 @@ click away:
>
>
>
-> _commit-check <version> · [Rules reference](https://commit-check.com/rules/)_
+> Checked by [Commit Check](https://commit-check.com) <version> · [Rules](https://commit-check.com/rules/) · [Check before you push](https://commit-check.com/guides/integrations/#as-a-pre-commit-hook)
The rest follow the same layout:
-- **Passed:** one line, `✅ All 3 checks passed`, with the tree folded away.
-- **Warned:** a rule under `warn` gets its own ⚠ row and counts as passed.
+- **Passed:** the heading reads "Commit Check passed", with the list folded away.
+- **Warned:** a rule under `warn` gets its own diff under "Warnings", a ⚠ in
+ the list, and counts as passed.
- **Skipped:** a run where nothing was validated — typically a bot listed in
- `ignore_authors` — reads `⊘`, never `✔`.
+ `ignore_authors` — reads "Commit Check skipped", never passed.
-The step log prints the same tree, plus one annotation per finding on the
-Files changed tab. With `pr-comments: true` the same report is posted to the
-pull request, and later runs edit that one comment instead of adding more.
+The step log prints the same list, each group folded under its own result, plus
+one annotation per finding on the run page. With `pr-comments: true` the same
+report is posted to the pull request, and later runs edit that one comment
+instead of adding more.
With `pr-body-ai-attribution: true` and `ai_attribution = "forbid"`, a
-description that credits an AI co-author fails the same way, and the report
-names the line to remove:
+description that credits an AI co-author fails the same way, and the diff is
+the line to remove:
-> ❌ **1 of 2 checks failed**
->
-> | Scope | Checked value | Failed checks |
-> |---|---|---|
-> | PR description | `Claude Code` | [CC013 ai-attribution](https://commit-check.com/rules/#cc013) |
->
-> ```text
-> Pull request
-> ✖ PR description (1 failure)
-> CC013 ai-attribution
-> value: Claude Code
-> AI attribution is forbidden in this project — detected: Claude Code
-> Suggest: In the description, remove "Co-Authored-By: Claude All 4 checks
> > ```text > Pull request -> ✔ PR title (feat: add login page) -> Commit message -> ✔ Commit 1/2 (d87faca) (feat: add login page) -> ✖ Commit 2/2 (5584f46) (1 failure) +> ✔ title feat: add login page +> Commits +> ✔ d87faca feat: add login page +> ✖ 5584f46 bad msg > CC001 message > value: bad msg > The commit message should follow Conventional Commits. > Suggest: Use![{STATUS_GLYPHS[status]}]({STATUS_MARK_URL}/{name}.png)
'
+ )
+
+def _group_lines(results: list[ScopeResult]) -> str:
+ """One line per group, its status mark in front: the overview."""
+ return "\n".join( + f"{_status_mark(status, 16, line=True)} {group_name}: {text}" + for group_name, scopes in _grouped(results) + for status, text in [_group_status(scopes)] + ) -def _markdown_details(results: list[ScopeResult]) -> str: - """Render the collapsible details block listing every scope. - Mirrors the step log layout (group name, ✔/✖ scope lines with the checked - value) and adds the failure reason and suggestion under each failing rule, - so one expand answers both "what was checked" and "what failed and why". - The same block is used whether or not anything failed — on a clean run the - failure branches simply never fire. +def _hunk(scope: ScopeResult, status: str) -> list[str]: + """One scope's findings as a diff hunk. + + ``@@ where @@``, then red for what was found and has to go, green for + what to write instead, and a ``#`` comment for advice that has no + literal text to offer. GitHub colours all three in a ``diff`` block, + which is the only colour a comment or a job summary can carry. """ - _failed, total = _check_counts(results) - unit = "check" if total == 1 else "checks" - label = f"Show all {total} {unit}" if total else "Show details" - body = _render_tree(results, include_docs=False) - # The tree quotes commit subjects, errors and suggestions as they are. A - # value with three backticks in it (a `docs:` commit showing a fence) - # would close a fixed ``` fence and spill the rest of the report out as - # prose, so the fence is one longer than any backtick run inside. - fence = "`" * max(3, _longest_backtick_run(body) + 1) - lines = ["
", f"
"])
- return "\n".join(lines)
+ is_commit = bool(scope.sha) and scope.label.startswith("Commit")
+ lines = [f"@@ {scope.sha[:7] if is_commit else scope.label} @@"]
+ removed: list[str] = []
+ added: list[str] = []
+ advice: list[str] = []
+ for check in _findings(scope, status):
+ minus, plus = _line_edits(scope, check)
+ removed.extend(minus)
+ added.extend(plus)
+ if not (minus or plus):
+ advice.append(_advice(check))
+ if scope.raw_text and not scope.checks:
+ advice.append("the output could not be parsed, see the step log")
+ removed, added, advice = (list(dict.fromkeys(x)) for x in (removed, added, advice))
+ value = _first_value(scope)
+ if value and value not in removed:
+ # Advice is about the value itself, so it is what was found; a fix
+ # that only touches other lines leaves it as context.
+ lines.append(f"{'-' if advice else ' '} {value}")
+ lines.extend(f"- {line}" for line in removed)
+ lines.extend(f"+ {line}" for line in added)
+ lines.extend(f"# {line}" for line in advice)
+ return lines
-def _longest_backtick_run(lines: list[str]) -> int:
- """Length of the longest run of consecutive backticks across ``lines``."""
- return max((len(m) for line in lines for m in re.findall(r"`+", line)), default=0)
+def _diff_block(results: list[ScopeResult], status: str = "fail") -> list[str]:
+ """The findings of one kind as a ``diff`` block, with their links under it.
+
+ A scope appears when it has an entry of the requested kind — checked via
+ ``scope.failures`` / ``scope.warnings``, not ``scope.status`` — so a scope
+ that both failed and warned shows up in both blocks.
+
+ A long list is cut at ``MAX_HUNKS`` and the rest folded away, so twenty
+ bad commits do not push the rest of the pull request off the screen. A
+ code block cannot hold links, so the commits shown and the rules that
+ spoke get one small line of them underneath.
+ """
+ scopes = [
+ scope
+ for scope in results
+ if _findings(scope, status)
+ or (status == "fail" and scope.raw_text and not scope.checks)
+ ]
+ hunks = [_hunk(scope, status) for scope in scopes]
+ shown = len(hunks) if len(hunks) <= MAX_HUNKS + HUNK_SLACK else MAX_HUNKS
+ lines = _fenced("diff", [line for hunk in hunks[:shown] for line in hunk])
+ if len(hunks) > shown:
+ rest = [line for hunk in hunks[shown:] for line in hunk]
+ lines += ["", "{label}
", "", f"{fence}text"] - lines.extend(body) - lines.extend([fence, "", "", f"
"]
+ commits = [
+ f"[`{scope.sha[:7]}`]({_commit_url(scope.sha)})"
+ for scope in scopes[:shown]
+ if scope.label.startswith("Commit") and _commit_url(scope.sha)
+ ]
+ rules = list(
+ dict.fromkeys(
+ _rule_ref(check) for scope in scopes for check in _findings(scope, status)
+ )
+ )
+ links = []
+ if commits:
+ links.append(f"Commits: {' '.join(commits)}")
+ if rules:
+ links.append(f"Rules: {' · '.join(rules)}")
+ if links:
+ lines += ["", f"{' | '.join(links)}"]
+ return lines
+
+
+#: First line of the prompt "How to fix" offers for an AI coding agent.
+AGENT_PROMPT = "Fix these Commit Check findings without changing any code:"
+BRANCH_HELP = (
+ "**Branch name.** Rename the branch and push it. A pull request cannot "
+ "change its branch, so open a new one from the renamed branch:"
+)
+AUTHOR_HELP = (
+ "**Author.** Set your git identity (`git config user.name`, "
+ "`git config user.email`), then `git commit --amend --reset-author` "
+ "and force-push."
+)
+HOOK_HELP = (
+ f"**Next time.** The [pre-commit hook]({LOCAL_HOOK_URL}) runs the same "
+ "rules before you push."
+)
+
+
+def _agent_prompt(failing: list[ScopeResult]) -> list[str]:
+ """A prompt to paste into an AI coding agent, one line per failing scope."""
+ lines = [AGENT_PROMPT]
+ for scope in failing:
+ todo = list(dict.fromkeys(_instruction(scope, c) for c in scope.failures))
+ is_commit = bool(scope.sha) and scope.label.startswith("Commit")
+ label = f"Commit {scope.sha[:7]}" if is_commit else scope.label
+ lines.append(f"- {_target(scope, todo, label)}: {'; '.join(todo)}")
+ return lines
+
+def _is_last_commit(scope: ScopeResult) -> bool:
+ """Whether the scope is the newest commit: ``Commit 3/3`` or the HEAD one."""
+ position = re.fullmatch(r"Commit (\d+)/(\d+)", scope.label)
+ return not position or position.group(1) == position.group(2)
-def _markdown_code(value: str) -> str:
- """A code span that survives a GFM table cell.
- The value is user text (a commit subject, a branch name, an author) and
- commonly quotes code. A bare ```` `{value}` ```` breaks twice on that: a
- backtick inside closes the span early, and an unescaped ``|`` splits the
- cell, pushing the rule link into a fourth column the table drops. So the
- span uses one more backtick than the longest run inside the value, pads
- with a space when the value starts or ends with a backtick (GFM strips
- one on each side, so the padding is invisible), and escapes ``|``, which
- GFM honours even inside a code span when the span sits in a table cell.
+def _reword_commands(commits: list[ScopeResult]) -> list[str]:
+ """The git commands that reword the failing commits and push the result."""
+ if len(commits) == 1 and _is_last_commit(commits[0]):
+ reword = "git commit --amend"
+ else:
+ first = commits[0].sha[:7] or "and {len(hunks) - shown} more
"] + lines += ["", *_fenced("diff", rest), "", "", "
"]
-def _scope_value(scope: ScopeResult, max_len: int = 60) -> str:
- """First non-empty check value for a scope, trimmed to a single line.
+def _all_checks(results: list[ScopeResult]) -> list[str]:
+ """The folded listing of every scope, passed ones included.
- The value is the concrete thing that was checked (PR title, commit
- subject, branch name, author name/email) and reads naturally next to
- the scope label in the success details. The 60-character cap keeps the
- full line (prefix + value + parentheses) short enough to avoid wrapping
- in the fenced details block.
+ The same rows the step log prints (group name, one ✔/✖ row per scope with
+ the checked value), with the rule's reason, suggestion and fix under each
+ finding, so one expand answers both "what was checked" and "what failed
+ and why". The same block is used whether or not anything failed.
"""
- for check in scope.checks:
- value = check.get("value", "")
- if value:
- first_line = value.splitlines()[0].strip()
- if len(first_line) > max_len:
- return first_line[: max_len - 3] + "..."
- return first_line
- return ""
+ _failed, total = _check_counts(results)
+ unit = "check" if total == 1 else "checks"
+ label = f"All {total} {unit}" if total else "Details"
+ body = _fenced("text", _render_tree(results, include_docs=False))
+ return ["How to fix
"] + for part in parts: + lines.extend(["", *part]) + return [*lines, "", "", f"
"]
# ---------------------------------------------------------------------------
# Output specification
#
# The Markdown report shared by the job summary and the PR comment renders
-# as follows (values are filled from ScopeResult data):
+# as follows (values are filled from ScopeResult data; {label}
", "", *body, "", "+#
+#
-#
+# @@ Branch @@
+# - login-page
+# # Use / with an allowed type
# ```
#
-#
-#
-# _commit-check 2.13.1 · [Rules reference](https://commit-check.com/rules/)_
-#
-# A commit scope names its commit by short hash after the label, on every
-# surface; the label itself ("Commit 1/11") stays bare in the `result` output.
-#
-# Skipped (every rule declined to run — e.g. the author is in ignore_authors):
+# Commits: [`5584f46`](…) [`37d6def`](…) | Rules: [CC001](…) · [CC013](…) · [CC201](…)
#
-# ⊘ **All 5 checks skipped** — nothing was validated
+# Show all 5 checks
-# -# ```text -# Commit message -# ✔ PR title (feat: add login page) -# ✔ Commit 1/11 (d87faca) (feat: add user auth) -# Branch -# ✔ Branch (feature/add-login) -# Author -# ✔ Author name (Jane Doe) -# ✔ Author email (jane@example.com) +# ```diff +# @@ 5584f46 @@ +# - bad msg +# + fix: bad msg +# @@ 37d6def @@ +# feat: add OAuth providers +# - Co-authored-by: Claude
+# "
+# - Branch "login-page": Use / with an allowed type
# ```
#
-# The reason comes from commit-check; an older CLI sends none, and the line
-# reads "(skipped)" with no "Skipped because" sentence.
+# **Commit messages.** Reword them, then force-push:
#
-# A skipped scope deliberately carries no ✔ and no checked value: nothing was
-# examined, so there is no value to report and no pass to claim. When only some
-# scopes skip, the verdict reads "✅ **3 of 5 checks passed**, 2 skipped".
+# ```bash
+# git rebase -i 5584f46~1 # change "pick" to "reword" on the commits above
+# git push --force-with-lease
+# ```
#
-# Warning (the repository's config lists a rule under the top-level `warn`):
+# **Branch name.** Rename the branch and push it. …
#
-#
-# ## Commit Check
+# **Next time.** The [pre-commit hook](…) runs the same rules before you push.
#
-# ✅ **3 of 4 checks passed**, 1 warning
-#
-# | Scope | Checked value | Warnings |
-# |---|---|---|
-# | Branch | `jsmith/fix-x` | [CC201 branch](https://commit-check.com/rules/#cc201) |
+#
#
# How to fix
# -# Skipped because author dependabot[bot] is in ignore_authors. +# **With an AI coding agent.** Paste this prompt: # # ```text -# Commit message -# ⊘ PR title (skipped: author dependabot[bot] is in [commit].ignore_authors) -# ⊘ Commit 1/1 (skipped: author dependabot[bot] is in [commit].ignore_authors) -# Branch -# ⊘ Branch (skipped: author dependabot[bot] is in [branch].ignore_authors) -# Author -# ⊘ Author name (skipped: author dependabot[bot] is in [commit].ignore_authors) -# ⊘ Author email (skipped: author dependabot[bot] is in [commit].ignore_authors) +# Fix these Commit Check findings without changing any code: +# - Commit 5584f46: change "bad msg" to "fix: bad msg" +# - Commit 37d6def "feat: add OAuth providers": remove "Co-authored-by: Claude
-# /
-# Author
-# ✔ Author name (Jane Doe)
-# ✔ Author email (jane@example.com)
+# Suggest: Use / with an allowed type, or …
# ```
#
#
#
-# _commit-check 2.17.0 · [Rules reference](https://commit-check.com/rules/)_
+# Checked by [Commit Check](https://commit-check.com) 2.20.5 · [Rules](…) · [Check before you push](…)
#
-# A warned scope is reported exactly like a failing one — its own table row,
-# its own entry in the details block — except the marker is ⚠ rather than ✖,
-# it counts toward "passed" rather than "failed", and it never turns the
-# workflow red. A real failure elsewhere still fails the run; the verdict
-# then reads "❌ **N of M checks failed**, K warnings" and both tables appear.
+# Success: the heading reads "Show all 4 checks
+#All 5 checks
# # ```text -# Commit message -# ✔ PR title (feat: add login page) +# Pull request +# ✔ title feat: add login page +# Commits +# ✔ d87faca feat: add login page +# ✖ 5584f46 bad msg +# CC001 message +# value: bad msg +# The commit message should follow Conventional Commits. +# Fix: fix: bad msg +# ✖ 37d6def feat: add OAuth providers +# CC013 ai-attribution +# value: Claude Code +# AI attribution is forbidden in this project — detected: Claude Code +# Suggest: … +# Fix: feat: add OAuth providers # Branch -# ⚠ Branch (1 warning) +# ✖ branch login-page # CC201 branch -# value: jsmith/fix-x +# value: login-page # The branch should follow Conventional Branch. -# Suggest: Use
-# ():
-# ✖ Commit 3/11 (37d6def) (1 failure)
-# CC002 subject-capitalized
-# value: feat: add login page
-# Subject must start with a capital letter
-# Fix: feat: Add login page
-# Branch
-# ✔ Branch (feature/add-login)
-# ```
-#
-#
-#
-# _commit-check 2.13.1 · [Rules reference](https://commit-check.com/rules/)_
-#
-# The step log prints the same tree (plus a `Docs:` line per finding), then one
-# annotation per finding whose message is the tree's detail joined on `%0A`:
-#
-# ::error title=CC002 subject-capitalized::Commit 3/11 (37d6def): Subject must start with a capital letter%0Avalue: feat: add login page%0AFix: feat: Add login page
-# ✖ commit-check: 2 of 5 checks failed
+# …
+# ::endgroup::
+# ::error title=CC001 message::Commit 2/3 (5584f46): change "bad msg" to "fix: bad msg"%0AThe commit message should follow Conventional Commits.
+# ✖ Commit Check: 2 of 5 checks failed
+# How to fix: see the job summary. Check before you push: https://commit-check.com/…
#
# The verdict is a plain line, not an `::error`, so the run's error count is
# the number of findings.
#
# Notes:
-# - The table's Scope cell links to the commit (GITHUB_SERVER_URL, so it is
-# right on GitHub Enterprise Server too); the tree cannot, being a code block.
-# - `Fix:` is the corrected text the CLI proposes, when the correction is
-# mechanical (CC002 capitalisation, CC010 WIP marker, CC012 sign-off, ...).
-# When the CLI's `suggest` is just `Use "Show all 5 checks
-# -# ```text -# Commit message -# ✔ PR title (feat: add login page) -# ✖ Commit 2/11 (5584f46) (1 failure) +# ::group::✖ Commits: 2 of 3 failed +# ✔ d87faca feat: add login page +# ✖ 5584f46 bad msg # CC001 message -# value: bad msg -# The commit message should follow Conventional Commits. -# Suggest: Use\n" + f"{group_line('✔', 'passed', 'Commits: 2 passed')}
\n" + f"{group_line('✔', 'passed', 'Branch: passed')}\n" "\n" "
\n"
- "
\n"
@@ -1916,7 +2027,8 @@ def test_success_golden_output(self):
@pin_version
def test_failure_golden_output(self):
- """Pin the full failure report: failed row in the table, all in details."""
+ """Pin the full failure report: the diff of what failed, how to fix
+ it, and every scope in the listing."""
results = [
pass_scope("PR title", value="feat: add login page"),
fail_scope("Commit 2/2"),
@@ -1926,29 +2038,55 @@ def test_failure_golden_output(self):
self.assertEqual(
body,
f"{main.COMMENT_MARKER}\n"
- f"{main.REPORT_TITLE}\n"
+ f"{heading('✖', 'failed', 'failed')}\n"
"\n"
- "❌ **1 of 3 checks failed**\n"
+ f"{group_line('✔', 'passed', 'Pull request: passed')}Show all 4 checks
\n" + "All 4 checks
\n" "\n" "```text\n" "Pull request\n" - " ✔ PR title (feat: add login page)\n" - "Commit message\n" - " ✔ Commit 1/2 (feat: add user auth)\n" - " ✔ Commit 2/2 (fix: resolve timeout)\n" + " ✔ title feat: add login page\n" + "Commits\n" + " ✔ d87faca feat: add user auth\n" + " ✔ 5584f46 fix: resolve timeout\n" "Branch\n" - " ✔ Branch (feature/add-login)\n" + " ✔ branch feature/add-login\n" "```\n" "\n" "\n" + f"{group_line('✖', 'failed', 'Commits: failed')}
\n" + f"{group_line('✔', 'passed', 'Branch: passed')}\n" "\n" - "| Scope | Checked value | Failed checks |\n" - "|---|---|---|\n" - "| Commit 2/2 | `bad message` | " - "[CC001 message](https://commit-check.com/rules/#cc001) |\n" + "```diff\n" + "@@ Commit 2/2 @@\n" + "- bad message\n" + "# Use
\n"
- "(): \n'
+ "```\n"
+ "\n"
+ "**Commit messages.** Reword it, then force-push:\n"
+ "\n"
+ "```bash\n"
+ "git commit --amend\n"
+ "git push --force-with-lease\n"
+ "```\n"
+ "\n"
+ f"{HOOK_HELP}\n"
+ "\n"
+ "
\n"
+ "\n"
+ "Show all 3 checks
\n" + "How to fix
\n" + "\n" + "**With an AI coding agent.** Paste this prompt:\n" + "\n" + "```text\n" + f"{AGENT_PROMPT}\n" + '- Commit 2/2 "bad message": Use\n"
+ "(): \n"
"Branch\n"
- " ✔ Branch (feature/add-login)\n"
+ " ✔ branch feature/add-login\n"
"```\n"
"\n"
"
\n"
@@ -1958,8 +2096,9 @@ def test_failure_golden_output(self):
@pin_version
def test_failure_golden_output_with_commits(self):
- """Pin the report for a pull request's commits: the table row links
- to the commit, the tree names it, and a mechanical fix is shown."""
+ """Pin the report for a pull request's commits: each is named by its
+ short hash, linked under the diff, and a mechanical fix is a green
+ line."""
results = [
pass_scope("PR title", value="feat: Add login page"),
fail_scope("Commit 1/3", sha=SHA_A),
@@ -1971,42 +2110,74 @@ def test_failure_golden_output_with_commits(self):
env = {"GITHUB_REPOSITORY": "acme/widgets", "GITHUB_SERVER_URL": ""}
with patch.dict(os.environ, env):
body = main.render_report(results)
+ commits = "https://github.com/acme/widgets/commit"
self.assertEqual(
body,
f"{main.COMMENT_MARKER}\n"
- f"{main.REPORT_TITLE}\n"
+ f"{heading('✖', 'failed', 'failed')}\n"
+ "\n"
+ f"{group_line('✔', 'passed', 'Pull request: passed')}All 3 checks
\n" "\n" "```text\n" "Pull request\n" - " ✔ PR title (feat: add login page)\n" - "Commit message\n" - " ✖ Commit 2/2 (1 failure)\n" + " ✔ title feat: add login page\n" + "Commits\n" + " ✖ 2/2 bad message\n" " CC001 message\n" " value: bad message\n" " The commit message should follow Conventional Commits.\n" " Suggest: Use\n" + f"{group_line('✖', 'failed', 'Commits: 2 of 3 failed')}
\n" + f"{group_line('✔', 'passed', 'Branch: passed')}\n" "\n" - "❌ **2 of 5 checks failed**\n" + "```diff\n" + "@@ d87faca @@\n" + "- bad message\n" + "# Use
\n"
- "(): \n'
+ '- Commit 5584f46: change "feat: add login page" to '
+ '"feat: Add login page"\n'
+ "```\n"
+ "\n"
+ "**Commit messages.** Reword them, then force-push:\n"
+ "\n"
+ "```bash\n"
+ 'git rebase -i d87faca~1 # change "pick" to "reword" on the '
+ "commits above\n"
+ "git push --force-with-lease\n"
+ "```\n"
+ "\n"
+ f"{HOOK_HELP}\n"
+ "\n"
+ "
\n"
+ "\n"
+ "Show all 5 checks
\n" + "How to fix
\n" + "\n" + "**With an AI coding agent.** Paste this prompt:\n" + "\n" + "```text\n" + f"{AGENT_PROMPT}\n" + '- Commit d87faca "bad message": Use\n"
+ "(): \n"
- " ✖ Commit 2/3 (5584f46) (1 failure)\n"
+ " ✖ 5584f46 feat: add login page\n"
" CC002 subject-capitalized\n"
" value: feat: add login page\n"
" Subject must start with a capital letter\n"
" Fix: feat: Add login page\n"
- " ✔ Commit 3/3 (37d6def) (fix: Handle timeout)\n"
+ " ✔ 37d6def fix: Handle timeout\n"
"Branch\n"
- " ✔ Branch (feature/add-login)\n"
+ " ✔ branch feature/add-login\n"
"```\n"
"\n"
"
\n"
@@ -2014,7 +2185,7 @@ def test_failure_golden_output_with_commits(self):
f"{FOOTER}",
)
- def test_table_link_honours_the_server_url(self):
+ def test_commit_link_honours_the_server_url(self):
"""GitHub Enterprise Server is not github.com."""
env = {
"GITHUB_REPOSITORY": "acme/widgets",
@@ -2023,26 +2194,36 @@ def test_table_link_honours_the_server_url(self):
with patch.dict(os.environ, env):
body = main.render_report([fix_scope("Commit 1/1", sha=SHA_B)])
self.assertIn(
- f"| [Commit 1/1 (5584f46)](https://ghe.example.com/acme/widgets/commit/{SHA_B}) |",
+ f"Commits: [`5584f46`](https://ghe.example.com/acme/widgets/commit/{SHA_B}) ",
body,
)
- def test_table_has_no_link_without_a_repository_to_link_into(self):
+ def test_no_commit_link_without_a_repository_to_link_into(self):
with patch.dict(os.environ, {"GITHUB_REPOSITORY": ""}):
body = main.render_report([fix_scope("Commit 1/1", sha=SHA_B)])
- self.assertIn("| Commit 1/1 (5584f46) | `feat: add login page` |", body)
+ self.assertIn("@@ 5584f46 @@\n- feat: add login page\n", body)
+ self.assertIn("\nRules: [CC002](", body)
self.assertNotIn("/commit/", body)
def test_scopes_without_a_commit_are_never_linked(self):
with patch.dict(os.environ, {"GITHUB_REPOSITORY": "acme/widgets"}):
body = main.render_report([fail_scope("Branch")])
- self.assertIn("| Branch | `bad message` |", body)
+ self.assertIn("@@ Branch @@\n- bad message\n", body)
+ self.assertNotIn("/commit/", body)
+
+ def test_an_author_scope_is_named_by_its_label_not_its_commit(self):
+ """An author check runs on a commit, but the finding is the author."""
+ scope = fail_scope("Author email", sha=SHA_A)
+ with patch.dict(os.environ, {"GITHUB_REPOSITORY": "acme/widgets"}):
+ body = main.render_report([scope])
+ self.assertIn("@@ Author email @@\n", body)
+ self.assertIn(" ✖ email bad message\n", body)
self.assertNotIn("/commit/", body)
def test_skipped_scope_carries_the_sha_too(self):
scope = skip_scope("Commit 1/1")
scope.sha = SHA_A
- self.assertIn(" ⊘ Commit 1/1 (d87faca) (skipped)", main.render_report([scope]))
+ self.assertIn(" ⊘ d87faca skipped\n", main.render_report([scope]))
def test_a_check_is_a_thing_checked_not_a_rule_evaluation(self):
"""The total counts scopes, so it tracks the policy, not the PR size.
@@ -2060,15 +2241,18 @@ def test_a_check_is_a_thing_checked_not_a_rule_evaluation(self):
make_check("subject_min_length", status="fail", rule_id="CC005"),
],
)
- body = main.render_report([pass_scope("Branch"), two_failures])
- self.assertIn("❌ **1 of 2 checks failed**", body)
- self.assertIn("All 5 checks
\n" "\n" "```text\n" "Pull request\n" - " ✔ PR title (feat: Add login page)\n" - "Commit message\n" - " ✖ Commit 1/3 (d87faca) (1 failure)\n" + " ✔ title feat: Add login page\n" + "Commits\n" + " ✖ d87faca bad message\n" " CC001 message\n" " value: bad message\n" " The commit message should follow Conventional Commits.\n" " Suggest: Use", body)
- self.assertIn("(): \n"
+ "```\n",
body,
)
- self.assertIn("
Show all 1 check
", body) + self.assertIn("All 1 check
", body) self.assertIn("```text", body) - self.assertIn("Branch", body) - self.assertIn(" ✔ Branch (main)", body) + self.assertIn("\nBranch\n ✔ branch main\n", body) + self.assertNotIn("```diff", body) + self.assertNotIn("How to fix", body) def test_all_pass_groups_scopes_like_step_log(self): results = [ @@ -2111,42 +2304,61 @@ def test_all_pass_groups_scopes_like_step_log(self): pass_scope("Author email", value="jane@example.com"), ] body = main.render_job_summary(results) - # Group headers in the details block mirror the step log ordering. - self.assertLess(body.index("Commit message"), body.index("Branch")) - self.assertLess(body.index("Branch"), body.index("Author")) - self.assertIn(" ✔ PR title (feat: add login page)", body) - self.assertIn(" ✔ Branch (feature/pr-12)", body) - self.assertIn(" ✔ Author email (jane@example.com)", body) + listing = body.split("```text\n")[1] + # Group headers in the listing mirror the step log ordering. + self.assertLess(listing.index("Commits\n"), listing.index("Branch\n")) + self.assertLess(listing.index("Branch\n"), listing.index("Author\n")) + self.assertIn(" ✔ title feat: add login page\n", listing) + self.assertIn(" ✔ branch feature/pr-12\n", listing) + self.assertIn(" ✔ email jane@example.com\n", listing) + self.assertIn("> Author: 2 passed", body) def test_all_pass_truncates_long_values(self): long_value = "x" * 200 body = main.render_job_summary([pass_scope("Commit 1/1", value=long_value)]) - self.assertIn(f" ✔ Commit 1/1 ({'x' * 57}...)", body) + self.assertIn(f" ✔ 1/1 {'x' * 57}...\n", body) def test_all_pass_without_value_shows_plain_label(self): body = main.render_job_summary([pass_scope("Branch")]) - self.assertIn(" ✔ Branch", body) - self.assertNotIn(" ✔ Branch (", body) + self.assertIn(" ✔ branch\n", body) - def test_failure_renders_table_with_rule_links(self): + def test_failure_shows_the_diff_and_the_rule_links(self): body = main.render_job_summary([fail_scope("Commit 1/1")]) - self.assertIn(main.REPORT_TITLE, body) - self.assertIn("❌ **1 of 1 check failed**", body) - self.assertIn("| Scope | Checked value | Failed checks |", body) + self.assertIn("Commit Check failed\n", body) + self.assertIn("> Commits: failed\n", body) self.assertIn( - "| Commit 1/1 | `bad message` | " - "[CC001 message](https://commit-check.com/rules/#cc001) |", + "```diff\n" + "@@ Commit 1/1 @@\n" + "- bad message\n" + "# Use", body)
- self.assertIn("(): ", body)
- self.assertIn("[Rules reference](https://commit-check.com/rules/)", body)
+ self.assertIn("[Rules](https://commit-check.com/rules/)", body)
+
+ def test_a_failing_value_is_printed_in_full(self):
+ """It is the one value the reader has to act on; the cap is for the
+ rows that passed."""
+ subject = "feat: " + "x" * 100
+ scope = main.ScopeResult(
+ label="Commit 1/1",
+ checks=[
+ make_check(
+ "subject_max_length", status="fail", rule_id="CC004", value=subject
+ )
+ ],
+ )
+ body = main.render_report([scope])
+ self.assertIn(f"- {subject}\n", body)
+ self.assertIn(f" ✖ 1/1 {subject}\n", body)
def test_failure_details_show_all_scopes_and_values(self):
results = [
@@ -2154,16 +2366,326 @@ def test_failure_details_show_all_scopes_and_values(self):
pass_scope("Commit 2/2", value="fix: resolve timeout"),
]
body = main.render_job_summary(results)
- self.assertIn("✔ Commit 2/2 (fix: resolve timeout)", body)
- self.assertIn("✖ Commit 1/2 (1 failure)", body)
+ self.assertIn(" ✔ 2/2 fix: resolve timeout\n", body)
+ self.assertIn(" ✖ 1/2 bad message\n", body)
- def test_pass_scope_renders_checkmark_without_value(self):
+ def test_passing_scopes_stay_out_of_the_diff(self):
body = main.render_job_summary([pass_scope("Branch"), fail_scope("Commit 1/1")])
- # Pass scopes stay out of the table; the details block carries them.
- table = body.split("
Show all 1 check
", body) - self.assertIn("```text", body) - self.assertIn("✖ Commit 1/1 (1 failure)", body) + self.assertIn( + "Rules: [CC001](https://commit-check.com/rules/#cc001)", body + ) + self.assertIn("All 1 check
", body) + self.assertIn(" ✖ 1/1 bad message\n", body) self.assertIn(" CC001 message", body) - # The failing value appears in full; the table truncates at 60. self.assertIn(" value: bad message", body) self.assertIn(" Suggest: Use")[0]
- self.assertNotIn("| Branch |", table)
- self.assertIn("| Commit 1/1 | `bad message` |", table)
- self.assertIn("✔ Branch", body)
+ diff = body.split("```diff\n")[1].split("```")[0]
+ self.assertEqual(diff.count("@@ "), 1)
+ self.assertIn("@@ Commit 1/1 @@", diff)
+ self.assertIn(" ✔ branch\n", body)
+
+
+def ai_scope(label: str = "Commit 1/1", sha: str = SHA_A) -> main.ScopeResult:
+ """A commit that credits an AI co-author, under ``ai_attribution = "forbid"``:
+ the rule's value is the tool, and its fix the message without the trailer."""
+ return main.ScopeResult(
+ label=label,
+ sha=sha,
+ text=(
+ "feat: add OAuth providers\n\n"
+ "Co-authored-by: Claude \n"
+ ),
+ checks=[
+ make_check(
+ "ai_attribution",
+ status="fail",
+ rule_id="CC013",
+ value="Claude Code",
+ error="AI attribution is forbidden in this project",
+ suggest="Remove the AI trailer lines and re-commit.",
+ fix="feat: add OAuth providers",
+ docs_url="https://commit-check.com/rules/#cc013",
+ )
+ ],
+ )
+
+
+class TestLineEdits(unittest.TestCase):
+ """What a rule's fix removes and adds, which the diff shows red and green."""
+
+ def test_a_subject_rule_is_compared_with_the_subject_alone(self):
+ """Its fix is the subject, so the body is not something it removed."""
+ scope = fix_scope()
+ scope.text = "feat: add login page\n\nThe body stays.\n"
+ self.assertEqual(
+ main._line_edits(scope, scope.checks[0]),
+ (["feat: add login page"], ["feat: Add login page"]),
+ )
+
+ def test_a_whole_message_fix_is_compared_with_the_whole_message(self):
+ message = "feat: add login page\n\nThe body stays."
+ scope = main.ScopeResult(
+ label="Commit 1/1",
+ text=message + "\n",
+ checks=[
+ make_check(
+ "require_signed_off_by",
+ status="fail",
+ rule_id="CC012",
+ value=message,
+ fix=f"{message}\n\nSigned-off-by: Jane Doe ",
+ )
+ ],
+ )
+ self.assertEqual(
+ main._line_edits(scope, scope.checks[0]),
+ ([], ["Signed-off-by: Jane Doe "]),
+ )
+
+ def test_an_ai_rule_is_compared_with_the_message_not_with_its_value(self):
+ """The value is the tool's name; the fix drops the trailer."""
+ scope = ai_scope()
+ self.assertEqual(
+ main._line_edits(scope, scope.checks[0]),
+ (["Co-authored-by: Claude "], []),
+ )
+
+ def test_an_ai_rule_without_the_message_has_no_line_to_name(self):
+ scope = ai_scope()
+ scope.text = ""
+ self.assertEqual(main._line_edits(scope, scope.checks[0]), ([], []))
+ self.assertEqual(
+ main._instruction(scope, scope.checks[0]),
+ "Remove the AI trailer lines and re-commit.",
+ )
+
+ def test_the_message_rule_supplies_the_text_outside_a_pull_request(self):
+ """Nothing is piped in for the HEAD commit, but the message rule's
+ value is the whole message."""
+ scope = ai_scope()
+ scope.checks.insert(0, make_check("message", value=scope.text.strip()))
+ scope.text = ""
+ self.assertEqual(
+ main._line_edits(scope, scope.checks[1]),
+ (["Co-authored-by: Claude "], []),
+ )
+ self.assertEqual(main._first_value(scope), "feat: add OAuth providers")
+
+ def test_a_rule_without_a_fix_has_no_edits(self):
+ scope = fail_scope()
+ self.assertEqual(main._line_edits(scope, scope.checks[0]), ([], []))
+
+ def test_a_fix_with_nothing_to_compare_it_with_has_no_edits(self):
+ scope = main.ScopeResult(
+ label="Branch", checks=[make_check("branch", status="fail", fix="x")]
+ )
+ self.assertEqual(main._line_edits(scope, scope.checks[0]), ([], []))
+
+ def test_recorded_edits_win_over_the_fix(self):
+ """A description is too long to carry as a fix, so its line changes
+ are recorded when it is checked."""
+ scope = fail_scope("PR description")
+ scope.edits["CC001"] = (["Generated with Claude Code"], [])
+ self.assertEqual(
+ main._line_edits(scope, scope.checks[0]),
+ (["Generated with Claude Code"], []),
+ )
+
+ def test_instruction_names_each_kind_of_change(self):
+ scope = fail_scope()
+ check = scope.checks[0]
+ cases = [
+ ((["a"], ["b"]), 'change "a" to "b"'),
+ ((["a", "b"], []), 'remove "a"; "b"'),
+ (([], ["c"]), 'add "c"'),
+ ((["a", "b"], ["c"]), 'remove "a"; "b", and add "c"'),
+ ]
+ for edits, expected in cases:
+ with self.subTest(expected=expected):
+ scope.edits["CC001"] = edits
+ self.assertEqual(main._instruction(scope, check), expected)
+
+ def test_advice_drops_what_only_the_rule_page_needs(self):
+ cases = {
+ "Use (): , where is one of: feat, fix": (
+ "Use (): "
+ ),
+ "Use / with an allowed type, or add the branch "
+ "to allow_branch_names in config": (
+ "Use / with an allowed type"
+ ),
+ 'In the description, remove "x"': 'remove "x"',
+ "Add a body\nexplaining the change": "Add a body",
+ }
+ for suggest, expected in cases.items():
+ with self.subTest(suggest=suggest):
+ check = make_check("message", status="fail", suggest=suggest)
+ self.assertEqual(main._advice(check), expected)
+
+ def test_advice_falls_back_to_the_error_without_its_link(self):
+ check = make_check(
+ "message",
+ status="fail",
+ error="Follow Conventional Commits. See https://www.conventionalcommits.org",
+ )
+ self.assertEqual(main._advice(check), "Follow Conventional Commits.")
+
+
+class TestDiffBlock(unittest.TestCase):
+ def _hunks(self, results, status="fail"):
+ lines = main._diff_block(results, status)
+ return lines[1 : lines.index("```")]
+
+ def test_a_fix_on_another_line_leaves_the_subject_as_context(self):
+ self.assertEqual(
+ self._hunks([ai_scope()]),
+ [
+ "@@ d87faca @@",
+ " feat: add OAuth providers",
+ "- Co-authored-by: Claude ",
+ ],
+ )
+
+ def test_advice_is_about_the_value_so_the_value_is_red(self):
+ scope = fail_scope("Commit 1/1", sha=SHA_A)
+ scope.checks.append(
+ make_check(
+ "subject_min_length",
+ status="fail",
+ rule_id="CC005",
+ value="bad message",
+ suggest="Write a subject of at least 20 characters",
+ )
+ )
+ self.assertEqual(
+ self._hunks([scope]),
+ [
+ "@@ d87faca @@",
+ "- bad message",
+ "# Use (): ",
+ "# Write a subject of at least 20 characters",
+ ],
+ )
+
+ def test_two_rules_that_ask_for_the_same_line_show_it_once(self):
+ scope = ai_scope()
+ scope.checks.append({**scope.checks[0], "rule_id": "CC015"})
+ self.assertEqual(len(self._hunks([scope])), 3)
+
+ def test_a_description_is_named_by_its_label_and_shows_only_the_lines(self):
+ scope = fail_scope("PR description")
+ scope.text = "Adds login.\n\nGenerated with Claude Code\n"
+ scope.edits["CC001"] = (["Generated with Claude Code"], [])
+ self.assertEqual(
+ self._hunks([scope]),
+ ["@@ PR description @@", "- Generated with Claude Code"],
+ )
+
+ def test_a_long_list_is_cut_and_the_rest_folded(self):
+ results = [fail_scope(f"Commit {n}/8", sha=f"{n}" * 40) for n in range(1, 9)]
+ with patch.dict(os.environ, {"GITHUB_REPOSITORY": "acme/widgets"}):
+ lines = main._diff_block(results)
+ body = "\n".join(lines)
+ shown, folded = body.split("
")
+ self.assertEqual(shown.count("@@ "), main.MAX_HUNKS)
+ self.assertIn("
\n" + f"{group_line('⊘', 'skipped', 'Commits: skipped')}\n" "\n" "
\n", body) + # Two scopes in the group, one of which ran: never "2 passed". + self.assertIn("> Pull request: 1 passed, 1 skipped\n", body) def test_failure_still_wins_over_skips(self): results = [fail_scope("Commit 1/1"), skip_scope("PR title")] body = main.render_report(results) - self.assertIn("❌ **1 of 2 checks failed**", body) + self.assertIn("Commit Check failed\n", body) + self.assertIn("> Commits: failed
\n", body) + self.assertIn("> Pull request: skipped\n", body) def test_skipped_scope_reports_no_checked_value(self): """The ⊘ line carries no value, because nothing was examined.""" body = main.render_report([skip_scope("PR title")]) - self.assertIn(" ⊘ PR title (skipped)", body) + self.assertIn(" ⊘ title skipped\n", body) def test_skip_reason_is_shown_on_the_scope_and_under_the_verdict(self): """A skip says why, so a deliberate bypass reads as one.""" @@ -3098,20 +3640,21 @@ def test_skip_reason_is_shown_on_the_scope_and_under_the_verdict(self): skip_scope("Branch", reason=branch), ] body = main.render_report(results) + self.assertIn("Commit Check skipped\n\nNothing was validated.\n", body) self.assertIn( - "⊘ **All 3 checks skipped** — nothing was validated\n\n" + "> Branch: skipped\n\n" "Skipped because author dependabot[bot] is in ignore_authors.\n", body, ) - self.assertIn(f" ⊘ PR title (skipped: {commit})", body) - self.assertIn(f" ⊘ Branch (skipped: {branch})", body) + self.assertIn(f" ⊘ title skipped: {commit}\n", body) + self.assertIn(f" ⊘ branch skipped: {branch}\n", body) def test_skip_reason_follows_a_partial_skip_verdict(self): reason = "author dependabot[bot] is in [branch].ignore_authors" results = [pass_scope("PR title"), skip_scope("Branch", reason=reason)] body = main.render_report(results) self.assertIn( - "✅ **1 of 2 checks passed**, 1 skipped\n\n" + "> Branch: skipped\n\n" "Skipped because author dependabot[bot] is in ignore_authors.\n", body, ) @@ -3120,7 +3663,10 @@ def test_skip_reason_reaches_the_step_log(self): reason = "author dependabot[bot] is in [commit].ignore_authors" with patch("sys.stdout", new_callable=io.StringIO) as out: main.render_step_log([skip_scope("PR title", reason=reason)]) - self.assertIn(f" ⊘ PR title (skipped: {reason})", out.getvalue()) + self.assertIn("::group::⊘ Pull request: skipped\n", out.getvalue()) + self.assertIn( + f" ⊘ title skipped: {reason}\n", ANSI_CODES.sub("", out.getvalue()) + ) self.assertIn( "Skipped because author dependabot[bot] is in ignore_authors.", out.getvalue(), @@ -3142,7 +3688,7 @@ def test_a_passing_scope_has_no_skip_reason(self): def test_older_engine_without_skip_is_unaffected(self): """Back-compat: engines that only emit pass/fail render as before.""" results = [pass_scope("Branch", value="main")] - self.assertIn("✅ **All 1 check passed**", main.render_report(results)) + self.assertIn("Commit Check passed\n", main.render_report(results)) def warn_scope(label: str = "Branch", value: str = "jsmith/fix-x") -> main.ScopeResult: @@ -3183,9 +3729,9 @@ def test_a_real_failure_outranks_a_warning_in_the_same_scope(self): def test_a_warning_survives_reporting_on_a_scope_that_also_fails(self): """The scope's status names its worst outcome, but both findings - still belong on every surface: the count, both tables, and the - details block. Filtering any of those on ``scope.status == "warn"`` - drops this scope's warning the moment its sibling rule fails. + still belong on every surface: the count, both diffs, and the + listing. Filtering any of those on ``scope.status == "warn"`` drops + this scope's warning the moment its sibling rule fails. """ mixed = main.ScopeResult( label="Branch", @@ -3212,15 +3758,33 @@ def test_a_warning_survives_reporting_on_a_scope_that_also_fails(self): self.assertEqual(main._warn_count([mixed]), 1) body = main.render_report([mixed]) - self.assertIn("❌ **1 of 1 check failed**, 1 warning", body) - self.assertIn("| Scope | Checked value | Failed checks |", body) - self.assertIn("[CC202 merge-base](https://commit-check.com/rules/#cc202)", body) - self.assertIn("| Scope | Checked value | Warnings |", body) - self.assertIn("[CC201 branch](https://commit-check.com/rules/#cc201)", body) - self.assertIn(" ✖ Branch (1 failure)", body) - self.assertIn(" CC202 merge-base", body) - self.assertIn(" ⚠ Branch (1 warning)", body) - self.assertIn(" CC201 branch", body) + self.assertIn("Commit Check failed\n", body) + failed, warned = body.split("**Warnings**") + self.assertIn( + "```diff\n" + "@@ Branch @@\n" + "- jsmith/fix-x\n" + "# Current branch is not rebased onto main.\n" + "```\n" + "\n" + "Rules: [CC202](https://commit-check.com/rules/#cc202)\n", + failed, + ) + self.assertIn( + "```diff\n" + "@@ Branch @@\n" + "- jsmith/fix-x\n" + "# Use/\n"
+ "```\n"
+ "\n"
+ "Rules: [CC201](https://commit-check.com/rules/#cc201)\n",
+ warned,
+ )
+ # One row, marked with the worse of the two, and both findings under
+ # it; the warning says that it is one.
+ self.assertIn(" ✖ branch jsmith/fix-x\n CC202 merge-base\n", body)
+ self.assertIn("\n CC201 branch (warning)\n", body)
+ self.assertNotIn("⚠ branch", body)
def test_step_log_and_report_agree_on_a_mixed_scope(self):
"""The step log's ::warning annotation must not be the only surface
@@ -3297,24 +3861,30 @@ def test_warning_only_golden_output(self):
self.assertEqual(
body,
f"{main.COMMENT_MARKER}\n"
- f"{main.REPORT_TITLE}\n"
+ f"{heading('⚠', 'warned', 'passed with warnings')}\n"
"\n"
- "✅ **1 of 2 checks passed**, 1 warning\n"
+ f"{group_line('✔', 'passed', 'Pull request: passed')}
\n" + f"{group_line('⚠', 'warned', 'Branch: 1 warning')}\n" "\n" - "| Scope | Checked value | Warnings |\n" - "|---|---|---|\n" - "| Branch | `jsmith/fix-x` | " - "[CC201 branch](https://commit-check.com/rules/#cc201) |\n" + "**Warnings**\n" + "\n" + "```diff\n" + "@@ Branch @@\n" + "- jsmith/fix-x\n" + "# Use/\n"
+ "```\n"
+ "\n"
+ "Rules: [CC201](https://commit-check.com/rules/#cc201)\n"
"\n"
"
and 3 more
\n\n```diff\n@@ 6666666 @@", folded) + self.assertEqual(folded.count("@@ "), 3) + # Only the commits in view are linked; the rule is named once. + links = lines[-1] + self.assertEqual(links.count("/commit/"), main.MAX_HUNKS) + self.assertNotIn("6666666", links) + self.assertEqual(links.count("[CC001]"), 1) + + def test_one_or_two_leftovers_are_not_worth_a_fold(self): + results = [fail_scope(f"Commit {n}/7", sha=f"{n}" * 40) for n in range(1, 8)] + body = "\n".join(main._diff_block(results)) + self.assertEqual(body.count("@@ "), 7) + self.assertNotIn("", body)
+
+ def test_warnings_get_the_same_block(self):
+ self.assertEqual(
+ self._hunks([warn_scope(), fail_scope()], "warn"),
+ ["@@ Branch @@", "- jsmith/fix-x", "# Use /"],
+ )
+
+
+class TestHowToFix(unittest.TestCase):
+ def _body(self, results):
+ return "\n".join(main._how_to_fix(results))
+
+ def test_nothing_failed_nothing_to_fix(self):
+ self.assertEqual(main._how_to_fix([pass_scope(), warn_scope()]), [])
+
+ def test_the_prompt_lists_every_failing_scope_with_its_instruction(self):
+ results = [
+ fail_scope("PR title"),
+ ai_scope("Commit 1/2"),
+ fix_scope("Commit 2/2"),
+ pass_scope("Branch"),
+ ]
+ self.assertIn(
+ "```text\n"
+ f"{AGENT_PROMPT}\n"
+ '- PR title "bad message": Use (): \n'
+ '- Commit d87faca "feat: add OAuth providers": remove '
+ '"Co-authored-by: Claude "\n'
+ '- Commit 5584f46: change "feat: add login page" to '
+ '"feat: Add login page"\n'
+ "```\n",
+ self._body(results),
+ )
+
+ def test_only_the_last_commit_failing_is_an_amend(self):
+ for scope in (
+ fail_scope("Commit 3/3", sha=SHA_A),
+ fail_scope("Commit message"),
+ ):
+ with self.subTest(label=scope.label):
+ body = self._body([scope])
+ self.assertIn("Reword it, then force-push:", body)
+ self.assertIn("```bash\ngit commit --amend\ngit push --force", body)
+ self.assertNotIn("rebase", body)
+
+ def test_an_earlier_commit_needs_a_rebase_from_its_parent(self):
+ body = self._body(
+ [fail_scope("Commit 2/3", sha=SHA_B), pass_scope("Commit 3/3")]
+ )
+ self.assertIn("```bash\ngit rebase -i 5584f46~1 # change", body)
+
+ def test_a_commit_without_a_hash_gets_a_placeholder(self):
+ body = self._body([fail_scope("Commit 1/3"), fail_scope("Commit 2/3")])
+ self.assertIn("Reword them, then force-push:", body)
+ self.assertIn("git rebase -i ~1 # change", body)
+
+ def test_each_kind_of_failure_gets_its_own_paragraph(self):
+ body = self._body(
+ [
+ fail_scope("PR title"),
+ fail_scope("PR description"),
+ fail_scope("Author email", sha=SHA_A),
+ fail_scope("Branch"),
+ ]
+ )
+ self.assertNotIn("**Commit messages.**", body)
+ self.assertIn("**Author.** Set your git identity", body)
+ self.assertIn(
+ "**Branch name.** Rename the branch and push it. A pull request cannot "
+ "change its branch, so open a new one from the renamed branch:\n\n"
+ "```bash\ngit branch -m /\ngit push -u origin HEAD\n```",
+ body,
+ )
+ self.assertIn(
+ "**Pull request title and description.** Edit them on the pull "
+ "request page.",
+ body,
+ )
+ self.assertTrue(body.endswith(f"{HOOK_HELP}\n\n
"))
+
+ def test_the_branch_command_uses_the_corrected_name_when_there_is_one(self):
+ scope = fail_scope("Branch")
+ scope.checks[0].update(value="Feature/Add-Login", fix="feature/Add-Login")
+ self.assertIn(
+ "```bash\ngit branch -m feature/Add-Login\ngit push -u origin HEAD\n```",
+ self._body([scope]),
+ )
+
+ def test_one_pull_request_field_is_it_not_them(self):
+ body = self._body([fail_scope("PR title")])
+ self.assertIn("**Pull request title.** Edit it on the pull request page.", body)
+ self.assertNotIn("**Branch name.**", body)
+ self.assertNotIn("**Author.**", body)
class TestRenderPrComment(unittest.TestCase):
@@ -2172,34 +2694,41 @@ def test_all_pass_matches_job_summary(self):
summary = main.render_job_summary([pass_scope("Branch")])
self.assertEqual(comment, summary)
self.assertTrue(comment.startswith(main.COMMENT_MARKER))
- self.assertIn("✅ **All 1 check passed**", comment)
+ self.assertIn("Commit Check passed\n", comment)
def test_failure_matches_job_summary(self):
comment = main.render_pr_comment([fail_scope("Commit 1/1")])
summary = main.render_job_summary([fail_scope("Commit 1/1")])
self.assertEqual(comment, summary)
self.assertTrue(comment.startswith(main.COMMENT_MARKER))
- self.assertIn("❌ **1 of 1 check failed**", comment)
- self.assertIn("| Scope | Checked value | Failed checks |", comment)
+ self.assertIn("Commit Check failed\n", comment)
+ self.assertIn("```diff\n@@ Commit 1/1 @@\n", comment)
class TestUnparsableScopeInTheReport(unittest.TestCase):
"""A CLI response that is not JSON is a failure with no rule to link."""
- def test_the_table_row_points_at_the_details(self):
+ def test_the_diff_points_at_the_step_log(self):
scope = main.ScopeResult(label="Branch", raw_text="Error: cchk.toml: oops")
body = main.render_report([scope])
- self.assertIn("❌ **1 of 1 check failed**", body)
+ self.assertIn("Commit Check failed\n", body)
self.assertIn(
- "| Branch | — | _output could not be parsed — see details_ |", body
+ "```diff\n"
+ "@@ Branch @@\n"
+ "# the output could not be parsed, see the step log\n"
+ "```\n",
+ body,
)
- # The details block is where the raw output went.
- self.assertIn(" ✖ Branch\n Error: cchk.toml: oops\n", body)
+ # No rule spoke, so there is none to link and nothing to instruct.
+ self.assertNotIn("Rules", body)
+ self.assertNotIn("How to fix", body)
+ # The listing is where the raw output went.
+ self.assertIn(" ✖ branch\n Error: cchk.toml: oops\n", body)
- def test_it_never_reaches_the_warnings_table(self):
+ def test_it_never_reaches_the_warnings(self):
scope = main.ScopeResult(label="Branch", raw_text="garbage")
- table = main._markdown_table([scope], "warn", "Warnings")
- self.assertEqual(table.splitlines()[2:], [])
+ self.assertNotIn("**Warnings**", main.render_report([scope]))
+ self.assertEqual(main._diff_block([scope], "warn")[:2], ["```diff", "```"])
class TestReportFooter(unittest.TestCase):
@@ -2208,8 +2737,9 @@ def test_names_the_installed_commit_check(self):
self.assertEqual(main._commit_check_version(), "9.8.7")
self.assertEqual(
main._report_footer(),
- "_commit-check 9.8.7 · "
- "[Rules reference](https://commit-check.com/rules/)_",
+ "Checked by [Commit Check](https://commit-check.com) 9.8.7 · "
+ "[Rules](https://commit-check.com/rules/) · "
+ f"[Check before you push]({HOOK_GUIDE})",
)
version.assert_called_with("commit-check")
@@ -2220,7 +2750,9 @@ def test_without_a_version_it_still_links_the_rules(self):
self.assertEqual(main._commit_check_version(), "")
self.assertEqual(
main._report_footer(),
- "_[Rules reference](https://commit-check.com/rules/)_",
+ "Checked by [Commit Check](https://commit-check.com) · "
+ "[Rules](https://commit-check.com/rules/) · "
+ f"[Check before you push]({HOOK_GUIDE})",
)
@@ -2240,7 +2772,7 @@ def test_success_writes_policy_report(self):
self.assertEqual(rc, 0)
with open(summary_path, encoding="utf-8") as file_obj:
content = file_obj.read()
- self.assertIn("✅ **All 1 check passed**", content)
+ self.assertIn("Commit Check passed\n", content)
def test_failure_returns_nonzero(self):
summary_path = os.path.join(tempfile.mkdtemp(), "summary.txt")
@@ -2252,8 +2784,8 @@ def test_failure_returns_nonzero(self):
self.assertEqual(rc, 1)
with open(summary_path, encoding="utf-8") as file_obj:
content = file_obj.read()
- self.assertIn("| Scope | Checked value | Failed checks |", content)
- self.assertIn("❌", content)
+ self.assertIn("Commit Check failed\n", content)
+ self.assertIn("```diff\n@@ Commit 1/1 @@\n- bad message\n", content)
def read_github_output(path: str) -> dict[str, str]:
@@ -2443,7 +2975,7 @@ def test_fork_pr_warning_names_only_the_surfaces_that_exist(self):
rc = main.add_pr_comments([pass_scope()])
self.assertEqual(rc, 0)
printed = mock_print.call_args[0][0]
- self.assertIn("annotations on the Files changed tab", printed)
+ self.assertIn("annotations on the run page", printed)
self.assertNotIn("job's summary", printed)
self.assertFalse(os.path.exists(summary_path))
@@ -2505,7 +3037,7 @@ def test_creates_comment_with_rendered_body(self):
self.assertEqual(mock_pull_request.create_comment.call_count, 1)
body = mock_pull_request.create_comment.call_args[1]["body"]
self.assertTrue(body.startswith(main.COMMENT_MARKER))
- self.assertIn("| Scope | Checked value | Failed checks |", body)
+ self.assertIn("```diff\n@@ Commit 1/1 @@\n- bad message\n", body)
def test_updates_existing_comment_when_changed(self):
# A report from an earlier version: no marker, and posted by the bot,
@@ -2951,7 +3483,9 @@ def test_running_the_script_runs_main(self):
mock_run.assert_not_called()
self.assertIn("::debug::MESSAGE=false\n", out.getvalue())
self.assertTrue(
- out.getvalue().endswith("✔ commit-check: all checks passed\n"),
+ ANSI_CODES.sub("", out.getvalue()).endswith(
+ "✔ Commit Check: all checks passed\n"
+ ),
out.getvalue(),
)
@@ -3053,18 +3587,21 @@ def test_all_skipped_golden_output(self):
self.assertEqual(
body,
f"{main.COMMENT_MARKER}\n"
- f"{main.REPORT_TITLE}\n"
+ f"{heading('⊘', 'skipped', 'skipped')}\n"
"\n"
- "⊘ **All 2 checks skipped** — nothing was validated\n"
+ "Nothing was validated.\n"
+ "\n"
+ f"{group_line('⊘', 'skipped', 'Pull request: skipped')}\n" + f"{group_line('⊘', 'skipped', 'Commits: skipped')}\n" "\n" "
\n"
- "
\n"
@@ -3074,19 +3611,24 @@ def test_all_skipped_golden_output(self):
def test_partial_skip_does_not_claim_all_passed(self):
results = [pass_scope("Branch", value="main"), skip_scope("PR title")]
+ results.append(pass_scope("PR description"))
body = main.render_report(results)
- self.assertIn("✅ **1 of 2 checks passed**, 1 skipped", body)
- self.assertNotIn("All 2 checks passed", body)
+ self.assertIn("Commit Check passed\n", body)
+ self.assertIn("> Branch: passedShow all 2 checks
\n" + "All 2 checks
\n" "\n" "```text\n" "Pull request\n" - " ⊘ PR title (skipped)\n" - "Commit message\n" - " ⊘ Commit 1/1 (skipped)\n" + " ⊘ title skipped\n" + "Commits\n" + " ⊘ 1/1 skipped\n" "```\n" "\n" "\n", body) + # Two scopes in the group, one of which ran: never "2 passed". + self.assertIn("> Pull request: 1 passed, 1 skipped\n", body) def test_failure_still_wins_over_skips(self): results = [fail_scope("Commit 1/1"), skip_scope("PR title")] body = main.render_report(results) - self.assertIn("❌ **1 of 2 checks failed**", body) + self.assertIn("Commit Check failed\n", body) + self.assertIn("> Commits: failed
\n", body) + self.assertIn("> Pull request: skipped\n", body) def test_skipped_scope_reports_no_checked_value(self): """The ⊘ line carries no value, because nothing was examined.""" body = main.render_report([skip_scope("PR title")]) - self.assertIn(" ⊘ PR title (skipped)", body) + self.assertIn(" ⊘ title skipped\n", body) def test_skip_reason_is_shown_on_the_scope_and_under_the_verdict(self): """A skip says why, so a deliberate bypass reads as one.""" @@ -3098,20 +3640,21 @@ def test_skip_reason_is_shown_on_the_scope_and_under_the_verdict(self): skip_scope("Branch", reason=branch), ] body = main.render_report(results) + self.assertIn("Commit Check skipped\n\nNothing was validated.\n", body) self.assertIn( - "⊘ **All 3 checks skipped** — nothing was validated\n\n" + "> Branch: skipped\n\n" "Skipped because author dependabot[bot] is in ignore_authors.\n", body, ) - self.assertIn(f" ⊘ PR title (skipped: {commit})", body) - self.assertIn(f" ⊘ Branch (skipped: {branch})", body) + self.assertIn(f" ⊘ title skipped: {commit}\n", body) + self.assertIn(f" ⊘ branch skipped: {branch}\n", body) def test_skip_reason_follows_a_partial_skip_verdict(self): reason = "author dependabot[bot] is in [branch].ignore_authors" results = [pass_scope("PR title"), skip_scope("Branch", reason=reason)] body = main.render_report(results) self.assertIn( - "✅ **1 of 2 checks passed**, 1 skipped\n\n" + "> Branch: skipped\n\n" "Skipped because author dependabot[bot] is in ignore_authors.\n", body, ) @@ -3120,7 +3663,10 @@ def test_skip_reason_reaches_the_step_log(self): reason = "author dependabot[bot] is in [commit].ignore_authors" with patch("sys.stdout", new_callable=io.StringIO) as out: main.render_step_log([skip_scope("PR title", reason=reason)]) - self.assertIn(f" ⊘ PR title (skipped: {reason})", out.getvalue()) + self.assertIn("::group::⊘ Pull request: skipped\n", out.getvalue()) + self.assertIn( + f" ⊘ title skipped: {reason}\n", ANSI_CODES.sub("", out.getvalue()) + ) self.assertIn( "Skipped because author dependabot[bot] is in ignore_authors.", out.getvalue(), @@ -3142,7 +3688,7 @@ def test_a_passing_scope_has_no_skip_reason(self): def test_older_engine_without_skip_is_unaffected(self): """Back-compat: engines that only emit pass/fail render as before.""" results = [pass_scope("Branch", value="main")] - self.assertIn("✅ **All 1 check passed**", main.render_report(results)) + self.assertIn("Commit Check passed\n", main.render_report(results)) def warn_scope(label: str = "Branch", value: str = "jsmith/fix-x") -> main.ScopeResult: @@ -3183,9 +3729,9 @@ def test_a_real_failure_outranks_a_warning_in_the_same_scope(self): def test_a_warning_survives_reporting_on_a_scope_that_also_fails(self): """The scope's status names its worst outcome, but both findings - still belong on every surface: the count, both tables, and the - details block. Filtering any of those on ``scope.status == "warn"`` - drops this scope's warning the moment its sibling rule fails. + still belong on every surface: the count, both diffs, and the + listing. Filtering any of those on ``scope.status == "warn"`` drops + this scope's warning the moment its sibling rule fails. """ mixed = main.ScopeResult( label="Branch", @@ -3212,15 +3758,33 @@ def test_a_warning_survives_reporting_on_a_scope_that_also_fails(self): self.assertEqual(main._warn_count([mixed]), 1) body = main.render_report([mixed]) - self.assertIn("❌ **1 of 1 check failed**, 1 warning", body) - self.assertIn("| Scope | Checked value | Failed checks |", body) - self.assertIn("[CC202 merge-base](https://commit-check.com/rules/#cc202)", body) - self.assertIn("| Scope | Checked value | Warnings |", body) - self.assertIn("[CC201 branch](https://commit-check.com/rules/#cc201)", body) - self.assertIn(" ✖ Branch (1 failure)", body) - self.assertIn(" CC202 merge-base", body) - self.assertIn(" ⚠ Branch (1 warning)", body) - self.assertIn(" CC201 branch", body) + self.assertIn("Commit Check failed\n", body) + failed, warned = body.split("**Warnings**") + self.assertIn( + "```diff\n" + "@@ Branch @@\n" + "- jsmith/fix-x\n" + "# Current branch is not rebased onto main.\n" + "```\n" + "\n" + "Rules: [CC202](https://commit-check.com/rules/#cc202)\n", + failed, + ) + self.assertIn( + "```diff\n" + "@@ Branch @@\n" + "- jsmith/fix-x\n" + "# Use
\n" + f"{group_line('⚠', 'warned', 'Branch: 1 warning')}\n" "\n" - "| Scope | Checked value | Warnings |\n" - "|---|---|---|\n" - "| Branch | `jsmith/fix-x` | " - "[CC201 branch](https://commit-check.com/rules/#cc201) |\n" + "**Warnings**\n" + "\n" + "```diff\n" + "@@ Branch @@\n" + "- jsmith/fix-x\n" + "# Use
\n"
- "/\n"
@@ -3325,30 +3895,43 @@ def test_warning_only_golden_output(self):
f"{FOOTER}",
)
- def test_warning_and_skip_both_fold_into_the_title_in_order(self):
- results = [pass_scope("PR title"), warn_scope(), skip_scope("Author")]
+ def test_warning_and_skip_each_get_their_own_group_line(self):
+ results = [pass_scope("PR title"), warn_scope(), skip_scope("Author name")]
body = main.render_report(results)
- self.assertIn("✅ **1 of 3 checks passed**, 1 warning, 1 skipped", body)
+ self.assertIn("Commit Check passed with warnings\n", body)
+ self.assertIn(
+ f"{group_line('✔', 'passed', 'Pull request: passed')}
\n" + f"{group_line('⚠', 'warned', 'Branch: 1 warning')}
\n" + f"{group_line('⊘', 'skipped', 'Author: skipped')}\n", + body, + ) def test_a_failure_still_fails_and_names_the_warning_too(self): results = [fail_scope("Commit 1/1"), warn_scope()] body = main.render_report(results) - self.assertIn("❌ **1 of 2 checks failed**, 1 warning", body) - self.assertIn("| Scope | Checked value | Failed checks |", body) - self.assertIn("| Scope | Checked value | Warnings |", body) - self.assertLess( - body.index("Failed checks"), - body.index("| Scope | Checked value | Warnings |"), - ) + self.assertIn("Commit Check failed\n", body) + self.assertEqual(body.count("```diff\n"), 2) + # The failures come first, the warnings under their own heading, and + # only the failures get instructions. + self.assertLess(body.index("@@ Commit 1/1 @@"), body.index("**Warnings**")) + self.assertLess(body.index("**Warnings**"), body.index("@@ Branch @@")) + self.assertLess(body.index("@@ Branch @@"), body.index("How to fix")) + self.assertNotIn("Branch name.", body) def test_step_log_prints_a_warning_annotation_not_an_error(self): buf = io.StringIO() with patch("sys.stdout", buf): main.render_step_log([warn_scope()]) out = buf.getvalue() - self.assertIn("::warning title=CC201 branch::Branch: The branch should ", out) + self.assertIn( + '::warning title=CC201 branch::Branch "jsmith/fix-x": ' + "Use/%0AThe branch should ",
+ out,
+ )
self.assertNotIn("::error", out)
- self.assertIn(" ⚠ Branch (1 warning)", out)
+ self.assertIn("::group::⚠ Branch: 1 warning\n", out)
+ self.assertIn(" \x1b[33m⚠\x1b[0m branch jsmith/fix-x\n", out)
+ self.assertNotIn("How to fix", out)
def test_step_log_friendly_line_mentions_the_warning(self):
buf = io.StringIO()
@@ -3415,16 +3998,12 @@ class TestMarkdownEscaping(unittest.TestCase):
"""User text in the report must not break the Markdown that carries it.
Commit subjects quote code, branch names and author names may contain
- pipes; the table cell and the fenced details block have to survive both.
- The checks below come from a real ``commit-check --format json`` run on
- the subject ``fix: handle `None` | retry`` (all rules pass on it, so the
- CC001 outcome is flipped to make a table row).
+ pipes; every value lands in a fenced block, and the fence has to survive
+ both. The checks below come from a real ``commit-check --format json``
+ run on the subject ``fix: handle `None` | retry`` (all rules pass on it,
+ so the CC001 outcome is flipped to make it a finding).
"""
- #: Splits a table row on the pipes that are cell separators, not on the
- #: escaped ones inside a cell.
- CELL_SEPARATOR = re.compile(r"(? main.ScopeResult:
return main.ScopeResult(
label="Commit 1/1",
@@ -3442,71 +4021,71 @@ def _scope(self, value: str) -> main.ScopeResult:
],
)
- def test_markdown_code_wraps_backticks_and_escapes_pipes(self):
- cases = {
- "plain": "`plain`",
- "a|b": "`a\\|b`",
- "fix: handle `None` | retry": "``fix: handle `None` \\| retry``",
- "`x`": "`` `x` ``",
- "``x``": "``` ``x`` ```",
- "x`": "`` x` ``",
- }
- for value, expected in cases.items():
- with self.subTest(value=value):
- self.assertEqual(main._markdown_code(value), expected)
-
- def test_table_row_with_backticks_and_a_pipe_keeps_three_cells(self):
- table = main._markdown_table([self._scope("fix: handle `None` | retry")])
- row = table.splitlines()[2]
- # Strip the outer pipes before counting: "| a | b | c |" -> 3 cells.
- cells = self.CELL_SEPARATOR.split(row.strip().strip("|"))
- self.assertEqual(len(cells), 3, row)
- self.assertEqual(cells[1].strip(), "``fix: handle `None` \\| retry``")
- self.assertEqual(
- cells[2].strip(), "[CC001 message](https://commit-check.com/rules/#cc001)"
- )
-
- def test_truncated_value_with_an_unbalanced_backtick_still_closes(self):
- """The 60-char cap can cut inside a backtick run; the fence is chosen
- after truncation, so the span still closes at the right place."""
+ def test_diff_fence_outgrows_a_triple_backtick_in_the_subject(self):
+ diff = main._diff_block([self._scope("docs: show ``` usage")])
+ self.assertEqual(diff[0], "````diff")
+ self.assertEqual(diff[2], "- docs: show ``` usage")
+ self.assertEqual(diff[4], "````")
+
+ def test_prompt_fence_outgrows_a_triple_backtick_in_the_subject(self):
+ how = main._how_to_fix([self._scope("docs: show ``` usage")])
+ self.assertIn("````text", how)
+ self.assertEqual(how.count("````"), 1)
+ # The commands quote nothing of the user's, so their fence stays.
+ self.assertIn("```bash", how)
+
+ def test_a_subject_with_a_pipe_or_backticks_is_shown_as_it_is(self):
+ """Every place a value lands is a code block, so nothing is escaped."""
+ subject = "fix: handle `None` | retry"
+ body = main.render_report([self._scope(subject)])
+ self.assertIn(f"- {subject}\n", body)
+ self.assertIn(f" ✖ 5584f46 {subject}\n", body)
+
+ def test_capped_value_with_an_unbalanced_backtick_stays_in_its_block(self):
+ """The 60-char cap can cut inside a backtick run."""
value = "fix: " + "`x`, " * 20
- truncated = main._scope_value(self._scope(value))
- self.assertTrue(truncated.endswith("`x..."), truncated) # cut mid-span
- cell = main._markdown_code(truncated)
- self.assertEqual(cell, f"``{truncated}``")
+ scope = pass_scope("Commit 1/1", value=value)
+ capped = main._scope_value(scope)
+ self.assertTrue(capped.endswith("`x..."), capped) # cut mid-span
+ listing = main._all_checks([scope])
+ self.assertEqual(listing[3], "```text")
+ self.assertEqual(listing[-3], "```")
def test_details_fence_outgrows_a_triple_backtick_in_the_value(self):
- details = main._markdown_details([self._scope("docs: show ``` usage")])
+ details = "\n".join(main._all_checks([self._scope("docs: show ``` usage")]))
lines = details.splitlines()
self.assertEqual(lines[3], "````text")
self.assertEqual(lines[-3], "````")
self.assertIn("value: docs: show ``` usage", details)
def test_details_fence_stays_three_backticks_for_ordinary_values(self):
- details = main._markdown_details([pass_scope(value="feat: add `login`")])
- lines = details.splitlines()
+ lines = main._all_checks([pass_scope(value="feat: add `login`")])
self.assertEqual(lines[3], "```text")
self.assertEqual(lines[-3], "```")
class TestSkipRenderingEdgeCases(unittest.TestCase):
- def test_failure_table_omits_skipped_scopes(self):
- """A skipped scope has no failed checks, so it must not get a row.
-
- It previously contributed a row with an empty value and an empty
- rule list — a blank accusation under "Failed checks".
- """
- table = main._markdown_table([fail_scope("Commit 1/1"), skip_scope("PR title")])
- self.assertIn("| Commit 1/1 |", table)
- self.assertNotIn("PR title", table)
- # header + separator + exactly one data row
- self.assertEqual(len(table.splitlines()), 3)
+ def test_the_diff_omits_skipped_scopes(self):
+ """A skipped scope has no failed checks, so it must not get a hunk:
+ a blank accusation among what failed otherwise."""
+ diff = main._diff_block([fail_scope("Commit 1/1"), skip_scope("PR title")])
+ self.assertEqual(
+ diff[:5],
+ [
+ "```diff",
+ "@@ Commit 1/1 @@",
+ "- bad message",
+ "# Use (): ",
+ "```",
+ ],
+ )
def test_empty_result_set_is_not_reported_as_all_skipped(self):
"""`skipped == total` is trivially true for no scopes at all."""
body = main.render_report([])
self.assertNotIn("skipped", body)
- self.assertIn("✅ **All 0 checks passed**", body)
+ self.assertIn("Commit Check passed\n\n
Show all 2 checks
\n" + "All 2 checks
\n" "\n" "```text\n" "Pull request\n" - " ✔ PR title (feat: add login page)\n" + " ✔ title feat: add login page\n" "Branch\n" - " ⚠ Branch (1 warning)\n" - " CC201 branch\n" + " ⚠ branch jsmith/fix-x\n" + " CC201 branch (warning)\n" " value: jsmith/fix-x\n" " The branch should follow Conventional Branch.\n" " Suggest: Use\n" + f"{group_line('⚠', 'warned', 'Branch: 1 warning')}
\n" + f"{group_line('⊘', 'skipped', 'Author: skipped')}\n", + body, + ) def test_a_failure_still_fails_and_names_the_warning_too(self): results = [fail_scope("Commit 1/1"), warn_scope()] body = main.render_report(results) - self.assertIn("❌ **1 of 2 checks failed**, 1 warning", body) - self.assertIn("| Scope | Checked value | Failed checks |", body) - self.assertIn("| Scope | Checked value | Warnings |", body) - self.assertLess( - body.index("Failed checks"), - body.index("| Scope | Checked value | Warnings |"), - ) + self.assertIn("Commit Check failed\n", body) + self.assertEqual(body.count("```diff\n"), 2) + # The failures come first, the warnings under their own heading, and + # only the failures get instructions. + self.assertLess(body.index("@@ Commit 1/1 @@"), body.index("**Warnings**")) + self.assertLess(body.index("**Warnings**"), body.index("@@ Branch @@")) + self.assertLess(body.index("@@ Branch @@"), body.index("How to fix")) + self.assertNotIn("Branch name.", body) def test_step_log_prints_a_warning_annotation_not_an_error(self): buf = io.StringIO() with patch("sys.stdout", buf): main.render_step_log([warn_scope()]) out = buf.getvalue() - self.assertIn("::warning title=CC201 branch::Branch: The branch should ", out) + self.assertIn( + '::warning title=CC201 branch::Branch "jsmith/fix-x": ' + "Use
\n", body)
+ self.assertIn(""