"""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 `::: : `. 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()]))