mutation_test.py

"""Simple mutation testing for Lua files.

This script mutates a variety of operators in the project's Lua business logic
files and runs the Lua test suite after each mutation.  It reports whether the
tests catch the mutation ("KILLED") or not ("SURVIVED").

Running this script requires a `lua` interpreter installed and assumes the test
suite can be executed with `lua my_test_suite.lua`.
"""

from __future__ import annotations

import subprocess
import sys
from pathlib import Path
from typing import Iterable, Tuple, List

from luaparser import ast
from luaparser import astnodes
import contextlib
import io


TEST_COMMAND = ["lua", "my_test_suite.lua"]

# All Lua files that contain business logic we want to mutate
FILES_TO_MUTATE: Iterable[Path] = [
    Path("evens.lua"),
    Path("logic/init.lua"),
    Path("modutils/init.lua"),
    Path("utils/init.lua"),
]

# Mapping of operator nodes to their mutated counterparts
OPERATOR_MUTATIONS = {
    astnodes.EqToOp: astnodes.NotEqToOp,
    astnodes.NotEqToOp: astnodes.EqToOp,
    astnodes.GreaterThanOp: astnodes.LessOrEqThanOp,
    astnodes.LessOrEqThanOp: astnodes.GreaterThanOp,
    astnodes.LessThanOp: astnodes.GreaterOrEqThanOp,
    astnodes.GreaterOrEqThanOp: astnodes.LessThanOp,
    astnodes.AndLoOp: astnodes.OrLoOp,
    astnodes.OrLoOp: astnodes.AndLoOp,
    astnodes.AddOp: astnodes.SubOp,
    astnodes.SubOp: astnodes.AddOp,
    astnodes.MultOp: astnodes.FloatDivOp,
    astnodes.FloatDivOp: astnodes.MultOp,
    astnodes.ModOp: astnodes.FloorDivOp,
    astnodes.FloorDivOp: astnodes.ModOp,
}


def parse_no_output(source: str) -> astnodes.Chunk:
    """Parse Lua source without printing the AST."""
    buf = io.StringIO()
    with contextlib.redirect_stdout(buf):
        return ast.parse(source)


def collect_operator_nodes(tree: astnodes.Chunk) -> list[astnodes.Node]:
    """Return all operator nodes we want to mutate in the AST."""
    nodes = []
    for node in ast.walk(tree):
        if isinstance(node, tuple(OPERATOR_MUTATIONS.keys())):
            nodes.append(node)
    return nodes


def mutate_operator(node: astnodes.Node) -> None:
    """Mutate the given operator node in place."""
    original_cls = node.__class__
    mutated_cls = OPERATOR_MUTATIONS.get(original_cls)
    if mutated_cls is None:
        return

    if hasattr(node, "left") and hasattr(node, "right"):
        mutated = mutated_cls(left=node.left, right=node.right)
    else:
        mutated = mutated_cls(operand=node.operand)  # type: ignore[arg-type]

    node.__class__ = mutated_cls
    node.__dict__.update(mutated.__dict__)


def get_position(node: astnodes.Node) -> tuple[int, int]:
    """Return (line, column) for the given AST node."""
    if hasattr(node, "_first_token"):
        token = node._first_token
        return getattr(token, "line", -1), getattr(token, "column", -1)
    return -1, -1


def run_tests() -> bool:
    """Run the Lua test suite and return True if tests pass."""
    result = subprocess.run(TEST_COMMAND, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    sys.stdout.buffer.write(result.stdout)
    return result.returncode == 0


def mutate_file(path: Path) -> Tuple[int, int, List[str]]:
    """Mutate the given file and return a tuple of (killed, survived, surviving details)."""
    killed = 0
    survived = 0
    surviving_details: List[str] = []

    original_code = path.read_text()
    tree = parse_no_output(original_code)
    operators = collect_operator_nodes(tree)

    for idx in range(len(operators)):
        tree = parse_no_output(original_code)
        operators = collect_operator_nodes(tree)
        node = operators[idx]
        line, col = get_position(node)
        original_name = node.__class__.__name__
        mutated_name = OPERATOR_MUTATIONS[node.__class__].__name__

        mutate_operator(node)
        path.write_text(ast.to_lua_source(tree))

        if run_tests():
            survived += 1
            status = "SURVIVED"
            surviving_details.append(f"{path}:{line}:{col} {original_name}->{mutated_name}")
        else:
            killed += 1
            status = "KILLED"
        print(f"{path} mutation {idx + 1}/{len(operators)}: {status}")

    # Restore original
    path.write_text(original_code)
    return killed, survived, surviving_details


def main() -> None:
    total_killed = 0
    total_survived = 0
    all_surviving: List[str] = []

    for file_path in FILES_TO_MUTATE:
        if not file_path.exists():
            continue
        killed, survived, details = mutate_file(file_path)
        total_killed += killed
        total_survived += survived
        all_surviving.extend(details)

    print(f"Killed: {total_killed}, Survived: {total_survived}")
    if all_surviving:
        print("\nSurviving mutants:")
        for d in all_surviving:
            print(f"  {d}")


if __name__ == "__main__":
    main()