80 lines
4.8 KiB
Python
80 lines
4.8 KiB
Python
"""Mutate a branch's changed lines with cargo-mutants, Stryker and Infection, each of which takes the changed lines itself."""
|
|
import os
|
|
import pathlib
|
|
|
|
from mutate_changes.changed_lines import by_folder, label, runs
|
|
from mutate_changes.tool_process import failed, Ran, remove, Run, scratch_folder
|
|
from failure import Failure
|
|
from git_cli.git_repo import Git
|
|
|
|
# cargo-mutants' exit codes for a run that finished: every mutant caught, some missed, and some timed out.
|
|
CARGO_FINISHED = frozenset({0, 2, 3})
|
|
CARGO_OUTCOMES = ("caught", "missed", "timeout", "unviable")
|
|
|
|
|
|
def run_cargo_mutants(top: str, base: str, paths: list[str], run: Run, git: Git, jobs: int) -> list[str] | Failure:
|
|
"""A line with cargo-mutants' mutant count, then a line per mutant it missed or that timed out, as `<path>:<line>:<column>: <outcome>: <mutation>`.
|
|
|
|
cargo-mutants runs in top."""
|
|
# cargo-mutants finds each file's path after a b/, a prefix that settings such as diff.mnemonicPrefix change.
|
|
diff = git("diff", "--no-color", "--no-ext-diff", "--no-textconv", "--src-prefix=a/", "--dst-prefix=b/", base, "--", *paths, cwd=top)
|
|
if isinstance(diff, Failure):
|
|
return diff
|
|
scratch = scratch_folder(top)
|
|
if isinstance(scratch, Failure):
|
|
return scratch
|
|
try:
|
|
pathlib.Path(scratch, "branch.diff").write_text(diff, encoding="utf-8")
|
|
relative = os.path.relpath(scratch, top)
|
|
ran = run(["cargo", "mutants", "--in-diff", os.path.join(relative, "branch.diff"), "--output", relative, "--jobs", str(jobs)], top)
|
|
if isinstance(ran, Failure) or ran.code not in CARGO_FINISHED:
|
|
return ran if isinstance(ran, Failure) else failed("cargo mutants", ran)
|
|
outcomes = {outcome: outcome_lines(pathlib.Path(scratch, "mutants.out", f"{outcome}.txt")) for outcome in CARGO_OUTCOMES}
|
|
except OSError as failure:
|
|
return Failure(f"could not hand cargo-mutants the diff or read its outcomes in {scratch}: {failure}")
|
|
finally:
|
|
remove(scratch)
|
|
uncaught = [f"{location}: {outcome}: {mutation}" for outcome in ("missed", "timeout") for location, _, mutation in (line.partition(": ") for line in outcomes[outcome])]
|
|
return [f"cargo-mutants: {sum(map(len, outcomes.values()))} mutants on changed lines, {len(uncaught)} not caught.", *uncaught]
|
|
|
|
|
|
def outcome_lines(path: pathlib.Path) -> list[str]:
|
|
return path.read_text(encoding="utf-8", errors="replace").splitlines() if path.is_file() else []
|
|
|
|
|
|
# Stryker and Infection also exit nonzero on a mutation score below a threshold the project sets, which their exit code doesn't
|
|
# tell from a run that broke, so either fails the run.
|
|
def run_stryker(top: str, changed: dict[str, frozenset[int]], run: Run, jobs: int) -> list[str] | Failure:
|
|
"""For each folder Stryker runs in, a line naming it, then Stryker's own report of the mutants on the changed lines. Last, a line
|
|
naming the files with no package.json above them, if any.
|
|
|
|
Stryker runs in the nearest folder above each file that holds a package.json. npx runs the project's own @stryker-mutator/core, else
|
|
one an earlier npx run cached, and installs none."""
|
|
report: list[str] = []
|
|
unplaced: list[str] = []
|
|
for folder, files in sorted(by_folder(top, changed, ("package.json",)).items()):
|
|
# by_folder falls back to top, where no package.json means there is no Stryker to run.
|
|
if not os.path.isfile(os.path.join(top, folder, "package.json")):
|
|
unplaced = sorted(files)
|
|
continue
|
|
mutate = ",".join(f"{path}:{first}-{last}" for path, lines in sorted(files.items()) for first, last in runs(lines))
|
|
ran = run(["npx", "--no", "--package=@stryker-mutator/core", "stryker", "run", "--mutate", mutate, "--concurrency", str(jobs), "--reporters", "clear-text"], os.path.join(top, folder))
|
|
if isinstance(ran, Failure) or ran.code:
|
|
return ran if isinstance(ran, Failure) else whole_output(f"Stryker in {label(folder)}", ran)
|
|
report.extend([f"Stryker in {label(folder)}:", *ran.output.splitlines()])
|
|
return [*report, *([f"Not mutated, as no package.json is above them: {', '.join(unplaced)}."] if unplaced else [])]
|
|
|
|
|
|
def run_infection(top: str, base: str, run: Run, jobs: int) -> list[str] | Failure:
|
|
"""A line naming where Infection ran, top, then its own report of the mutants on the lines the branch changes since base."""
|
|
ran = run(["vendor/bin/infection", "--git-diff-lines", f"--git-diff-base={base}", f"--threads={jobs}", "--show-mutations=max", "--no-progress"], top)
|
|
if isinstance(ran, Failure) or ran.code:
|
|
return ran if isinstance(ran, Failure) else whole_output("Infection", ran)
|
|
return ["Infection in the checkout's top:", *ran.output.splitlines()]
|
|
|
|
|
|
def whole_output(name: str, ran: Ran) -> Failure:
|
|
"""A tool's exit code and its whole output. Stryker and Infection also exit nonzero on a mutation score below the project's threshold,
|
|
where the output is the report of what survived."""
|
|
return Failure("\n".join([f"{name} exited {ran.code}:", *ran.output.splitlines()]))
|