Raven-1/tests/test_check_commit_messages.py
zhanghui b91abe5e09
ci(*): keep commit lint off the default branch's history (#531)
## Summary

A pull request whose base is not the default branch carries, in its
`BASE..HEAD` range, every commit the default branch has gained since the
two
diverged. Both commit linters read that range, so they re-read history
that
already passed this gate when it landed and that nobody can rewrite now.

#529 is the case that surfaced it: merging `main` into
`refactor/ui_web_architecture` puts 38 `main` commits in range, one of
which
(`b01534d0`, #471) carries a `Co-authored-by` trailer with a non-ASCII
name.
The gate reports that PR red for a message it did not write. The same
will
happen to every future catch-up merge.

`scripts/check_commit_messages.py` now takes several revision arguments
and
passes them to `git log`, so a caret exclusion works. Commitlint has no
equivalent flag, so the workflow iterates the same revision list and
lints one
message at a time. On a pull request the workflow excludes the
repository's
default branch; a push to the default branch is unchanged and still
lints what
it pushed.

This does not touch the offending commit on `main` and does not relax a
rule:
a commit that a PR actually introduces is linted exactly as before.

## Type

- [ ] Fix
- [ ] Feature
- [ ] Docs
- [x] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

`uv run pytest tests/test_check_commit_messages.py
tests/test_commit_lint.py -q`
-- 15 passed. Three of those cases are new and cover a repo where the
default
branch carries a rejected message and the feature branch merges it in:
the
range fails without an exclusion, passes with one, and still fails when
the
bad commit is the branch's own.

Mutation check on the new cases: replacing `_commit_messages(args)` with
`_commit_messages(args[:1])`, which is the behaviour before this change,
turns
`test_excluding_the_default_branch_skips_the_history_it_carries` red and
leaves
the other three green. The pin fails when the fix is removed.

Against the real history behind #529, with the checker run directly:

- `check_commit_messages.py "bc74bf73..a0666244c"` -- exit 1, naming
  `b01534d02` exactly as CI does.
- the same range plus `^github/main` -- exit 0.

The workflow's new loop was run as written against both ranges: 0
commits to
lint on the catch-up range, and a planted `Update stuff.` commit on a
feature
branch still sets the failure flag.

`make lint-python` -- clean. `scripts/check_source_language.py` over the
branch
-- exit 0; the test's non-ASCII message is built from an escape, so the
file
itself stays ASCII.

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [ ] User-facing docs or screenshots are updated when needed

## Risk

Commitlint now starts once per commit instead of once per range, so a PR
with
many commits spends a second or so more in this job. The exclusion only
ever
removes commits that are already on the default branch, so nothing a PR
introduces escapes either linter.

Rollback is reverting this PR; the previous behaviour is one range
argument and
one commitlint invocation.

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

## Related Issues

N/A. Unblocks the `commit messages` check on #529.

---------

Co-authored-by: gloryfromca <23442919+gloryfromca@users.noreply.github.com>
Co-authored-by: Claude (claude-opus-5) <noreply@anthropic.com>
2026-09-20 15:21:54 +08:00

121 lines
3.5 KiB
Python

"""The commit-range linter over a real git repo, merge commits and exclusions included."""
from __future__ import annotations
import os
import subprocess
from pathlib import Path
from scripts import check_commit_messages
def _git(cwd: Path, *args: str) -> str:
env = {
"GIT_AUTHOR_NAME": "Test",
"GIT_AUTHOR_EMAIL": "test@example.com",
"GIT_COMMITTER_NAME": "Test",
"GIT_COMMITTER_EMAIL": "test@example.com",
"GIT_CONFIG_GLOBAL": "/dev/null",
"GIT_CONFIG_SYSTEM": "/dev/null",
"PATH": os.environ["PATH"],
}
return subprocess.check_output(["git", *args], cwd=cwd, text=True, env=env).strip()
def _init_repo(root: Path) -> None:
_git(root, "init", "-q", "-b", "main")
(root / "a.txt").write_text("a\n")
_git(root, "add", "a.txt")
_git(root, "commit", "-qm", "feat: seed initial file")
def test_range_with_merge_commit_passes(tmp_path: Path) -> None:
repo = tmp_path / "repo"
repo.mkdir()
_init_repo(repo)
base = _git(repo, "rev-parse", "HEAD")
_git(repo, "checkout", "-q", "-b", "feature")
(repo / "b.txt").write_text("b\n")
_git(repo, "add", "b.txt")
_git(repo, "commit", "-qm", "feat: add feature file")
_git(repo, "checkout", "-q", "main")
(repo / "c.txt").write_text("c\n")
_git(repo, "add", "c.txt")
_git(repo, "commit", "-qm", "feat: add main file")
_git(repo, "checkout", "-q", "feature")
_git(repo, "merge", "--no-ff", "-m", "Merge branch 'main' into feature", "main")
cwd = Path.cwd()
try:
os.chdir(repo)
exit_code = check_commit_messages.main([f"{base}..HEAD"])
finally:
os.chdir(cwd)
assert exit_code == 0
# Not a literal: this file is under the repo's English-source rule, and the case
# needs a message that breaks the ASCII rule at runtime.
_NON_ASCII = "feat: add a file named \u2014 the dash"
def _merge_history(repo: Path) -> str:
"""main gains one message that fails the gate; feature merges main in."""
_init_repo(repo)
base = _git(repo, "rev-parse", "HEAD")
_git(repo, "checkout", "-q", "-b", "feature")
(repo / "b.txt").write_text("b\n")
_git(repo, "add", "b.txt")
_git(repo, "commit", "-qm", "feat: add feature file")
_git(repo, "checkout", "-q", "main")
(repo / "c.txt").write_text("c\n")
_git(repo, "add", "c.txt")
_git(repo, "commit", "-qm", _NON_ASCII)
_git(repo, "checkout", "-q", "feature")
_git(repo, "merge", "--no-ff", "-m", "Merge branch 'main' into feature", "main")
return base
def _run(repo: Path, *revisions: str) -> int:
cwd = Path.cwd()
try:
os.chdir(repo)
return check_commit_messages.main(list(revisions))
finally:
os.chdir(cwd)
def test_the_default_branch_history_is_linted_without_an_exclusion(tmp_path: Path) -> None:
repo = tmp_path / "repo"
repo.mkdir()
base = _merge_history(repo)
assert _run(repo, f"{base}..HEAD") == 1
def test_excluding_the_default_branch_skips_the_history_it_carries(tmp_path: Path) -> None:
repo = tmp_path / "repo"
repo.mkdir()
base = _merge_history(repo)
assert _run(repo, f"{base}..HEAD", "^main") == 0
def test_the_exclusion_still_lints_the_branch_its_own_commits(tmp_path: Path) -> None:
repo = tmp_path / "repo"
repo.mkdir()
base = _merge_history(repo)
(repo / "d.txt").write_text("d\n")
_git(repo, "add", "d.txt")
_git(repo, "commit", "-qm", _NON_ASCII)
assert _run(repo, f"{base}..HEAD", "^main") == 1