148 lines
11 KiB
Python
148 lines
11 KiB
Python
#!/usr/bin/env python3
|
||
# Row 162 mutants M1-M46 (agents/darkwing/work/queue-162/BUILD.md). Each mutant is exact-string
|
||
# edits to one file in the r162 worktree; the named tests must fail. The file is restored from a
|
||
# pristine copy after every mutant and checked by sha256. Run with python3 -I.
|
||
import hashlib, os, re, shutil, signal, subprocess, sys, time
|
||
|
||
HOME = os.environ["HOME"]
|
||
R = f"{HOME}/darkwing-scratch/r162"
|
||
WT = f"{R}/wt"
|
||
OUT = f"{R}/out/mutants"
|
||
TEST = "packages/cli/tests/stack-release.test.mjs"
|
||
SR = "scripts/stack-release.sh"
|
||
SC = "scripts/stack-copy.sh"
|
||
|
||
def sha(p):
|
||
return hashlib.sha256(open(p, "rb").read()).hexdigest()
|
||
|
||
M = []
|
||
def mut(mid, pattern, edits, f=SR, expect=None):
|
||
M.append((mid, pattern, edits, f, expect))
|
||
|
||
mut("M1", "^T1 ", [(' [ ! -f "$POINTER" ] || { read_pointer; FROM="$P_COPY"; refuse already-adopted "$POINTER exists (copy $P_COPY)"; }\n', "")])
|
||
mut("M2", "^T[12] ", [(' if [ "${argv[i]}" = --checkout ]; then i=$((i + 1)); continue; fi\n', "")])
|
||
mut("M3", "^T2 ", [(' --claude "$claude" >> "$STEPS"', ' >> "$STEPS"')])
|
||
mut("M4", "^T3 ", [(' [ "${P_CONSOLE[*]}" = "${U_CONSOLE[*]}" ] || d+=$\'\\n\'" console:', ' true || d+=$\'\\n\'" console:')])
|
||
mut("M5", "^T4 ", [(" instance_busy\n drop_in_override\n", " drop_in_override\n")])
|
||
mut("M6", "^T4 ", [(" instance_busy\n drop_in_override\n", " instance_busy\n")])
|
||
mut("M7", "^T4 ", [('copy_ok "$TO" 2>/dev/null || refuse copy-unreachable', 'true || refuse copy-unreachable')])
|
||
mut("M8", "^T4 ", [('|| log_line result refused code "$code"', "|| true")])
|
||
mut("M9", "^T5 ", [(' systemctl --user stop "$CONSOLE_UNIT" || return 1\n systemctl --user stop "$BUS_UNIT" || return 1\n',
|
||
' systemctl --user stop "$BUS_UNIT" || return 1\n systemctl --user stop "$CONSOLE_UNIT" || return 1\n')])
|
||
mut("M10", "^T5 ", [('systemctl --user start "$BUS_UNIT" && systemctl --user start "$CONSOLE_UNIT"',
|
||
'systemctl --user start "$CONSOLE_UNIT" && systemctl --user start "$BUS_UNIT"')])
|
||
mut("M11", "^T6 ", [(' [ "$MIGRATE" = 1 ] || rollback_in_run migration-needs-flag\n', "")])
|
||
mut("M12", "^T7 ", [(' backup_store || rollback_in_run backup\n node "$COPIES/$TO/packages/bus/src/migrate-schema.mjs" "$DATA" >> "$STEPS" 2>&1 || rollback_in_run migrate-failed\n',
|
||
' node "$COPIES/$TO/packages/bus/src/migrate-schema.mjs" "$DATA" >> "$STEPS" 2>&1 || rollback_in_run migrate-failed\n backup_store || rollback_in_run backup\n')])
|
||
mut("M13", "^T8 ", [(' elif [ -n "$TAKEN" ] && ! restore_store "$TAKEN"; then rcode=restore\n', "")])
|
||
mut("M14", "^T9 ", [(' if [ "$STORE_SCHEMA" != "$T_SCHEMA" ]; then\n', ' if [ "$STORE_SCHEMA" != "$T_SCHEMA" ] && in_chain "$STORE_SCHEMA"; then\n')])
|
||
mut("M15", "^T10 ", [(' systemctl --user is-active --quiet "$BUS_UNIT" && systemctl --user is-active --quiet "$CONSOLE_UNIT" || return 1\n GATE=bus-status\n',
|
||
' true || return 1\n GATE=bus-status\n')], expect="units-inactive")
|
||
mut("M16", "^T10 ", [(" GATE=bus-status\n", " GATE=bus-status\n if false; then\n"),
|
||
(' [ -z "$GATE_WHY" ] || return 1\n GATE=healthz\n', ' fi\n GATE=healthz\n')], expect="bus-status")
|
||
mut("M17", "^T10 ", [('-- "$(console_port)" || return 1', '-- "$(console_port)" || true')], expect="healthz")
|
||
mut("M18", "^T10 ", [('--business "$BUSINESS" > /dev/null 2>&1 || return 1', '--business "$BUSINESS" > /dev/null 2>&1 || true')], expect="copy-check")
|
||
mut("M19", "^T10 ", [('pm_launched "$copy" || return 1', 'pm_launched "$copy" || true')], expect="pm-launch-unconfirmed")
|
||
mut("M20", "^T10 ", [(' gate "$TO" "$P_PM" || after_fail "$GATE"\n trap - INT TERM HUP\n write_pointer "$TO" "$P_PM" "$P_CLAUDE" "$T_SCHEMA" "${P_CONSOLE[@]}"\n',
|
||
' write_pointer "$TO" "$P_PM" "$P_CLAUDE" "$T_SCHEMA" "${P_CONSOLE[@]}"\n gate "$TO" "$P_PM" || after_fail "$GATE"\n trap - INT TERM HUP\n')])
|
||
mut("M21", "^T10 ", [(' tmp="$(mktemp "$BIN/.mosaic.XXXXXX")" && cp -p "$RS/wrapper" "$tmp" && chmod "$(cat "$RS/WRAPPER_MODE")" "$tmp" && mv -f "$tmp" "$BIN/mosaic" || return 1\n', ""),
|
||
(' [ "$(sha256sum < "$BIN/mosaic" | cut -d\' \' -f1)" = "$(sum_of "$RS" wrapper)" ] || return 1\n [ "$(stat -c %a "$BIN/mosaic")" = "$(cat "$RS/WRAPPER_MODE")" ] || return 1\n', "")])
|
||
mut("M22", "^T11 ", [(' elif ! gate "$P_COPY" "$P_PM"; then rcode="$GATE"\n',
|
||
' elif ! gate "$P_COPY" "$P_PM" && ! { start_both && gate "$P_COPY" "$P_PM"; }; then rcode="$GATE"\n')])
|
||
mut("M23", "^T12 ", [('if(mode==="previous"&&o.to!==current)', 'if(mode==="previous")')])
|
||
mut("M24", "^T13 ", [('[ "$P_SCHEMA" = "$T_SCHEMA" ] || [ -n "$RESTORE" ] || refuse schema-differs', 'true || refuse schema-differs')])
|
||
mut("M25", "^T14 ", [('[ "$COUNT" = 0 ] || [ "$EVENTS" = "$COUNT" ] || refuse post-backup-events', '[ "$COUNT" = 0 ] || [ -n "$EVENTS" ] || refuse post-backup-events')])
|
||
mut("M26", "^T15 ", [('if [ "$PLAN" = 1 ]; then check_target; plan; exit 0; fi', 'if [ "$PLAN" = 1 ]; then log_line result planned; check_target; plan; exit 0; fi', 2)])
|
||
mut("M27", "^T(8|13) ", [(' mv "$DATA/bus" "$POST" || return 1\n', ' mv "$DATA/bus" "$POST" && rm -rf "$POST" || return 1\n')])
|
||
mut("M28", "^T4 ", [('git -C "$REPO" merge-base --is-ancestor "$1" "$ref" || die', 'true || die')], f=SC)
|
||
mut("M29", "^T4 ", [('case "$state" in activating|deactivating|reloading) refuse instance-busy "$unit is $state" ;; esac', ":")])
|
||
mut("M30", "^T10b ", [(' [ "${#lines[@]}" -gt 0 ] || { GATE_WHY="no launched line since the start"; return 1; }\n',
|
||
' [ "${#lines[@]}" -gt 0 ] || lines=("launched x: run $("$1/scripts/mosaic" launches list --json 2>/dev/null | node -e \'const s=JSON.parse(require("fs").readFileSync(0,"utf8")).find((x)=>x.live);process.stdout.write(s?s.run:"none")\'), y")\n')],
|
||
expect="a human launch with no journal line")
|
||
mut("M31", "^T14b ", [(' [ -z "$RESTORED" ] || rollback_failed "$1" not-attempted\n', "")])
|
||
mut("M32", "^T19 ", [('[ -z "$open" ] || refuse interrupted-run', 'true || refuse interrupted-run')])
|
||
mut("M33", "^T20 ", [("flock -n 9 || refuse run-locked", "true || refuse run-locked")])
|
||
mut("M34", "^T21 ", [('[ -n "$U_CLAUDE" ] || refuse no-claude-pin', 'true || refuse no-claude-pin', 2)])
|
||
mut("M35", "^T10b ", [('--since "@$START_EPOCH"', '--since "$(date -d "@$START_EPOCH" \'+%Y-%m-%d %H:%M:%S\')"')], expect="one well-formed line and a live run pass")
|
||
mut("M36", "^T10b ", [(' [ "${#lines[@]}" = 1 ] || { GATE_WHY="${#lines[@]} launched lines since the start"; return 1; }\n', "")], expect="two lines")
|
||
mut("M37", "^T10b ", [(':!(Date.parse(s.startedAt)>=Number(since))?`run ${run} started before this start`', "")], expect="run started before the start")
|
||
mut("M38", "^T22 ", [('if [ -e "$f" ] || [ -L "$f" ]; then UNCLEAN="$f"; return 0; fi', ":")])
|
||
mut("M39", "^T22 ", [('new DatabaseSync(pathToFileURL(file).href+"?immutable=1",{readOnly:true})', "new DatabaseSync(file,{readOnly:true})")], expect="clean")
|
||
mut("M40", "^T14c ", [(' [ -z "$RESTORED" ] || rollback_failed "$1" not-attempted\n', ' [ -z "$RESTORED" ] && [ "$OP" != rollback ] || rollback_failed "$1" not-attempted\n')])
|
||
mut("M41", "^T23 ", [(' echo "needs: Jason present for this run (decision 96 condition 2)"\n', "")])
|
||
mut("M42", "^T(23|20) ", [(' [ "$PLAN" = 1 ] || lock\n', " lock\n", 2)])
|
||
mut("M43", "^T23 ", [(' S_SCHEMA="$(store_read version 2>/dev/null)" || S_SCHEMA=""\n', ' S_SCHEMA="$(node -e "$STORE_JS" -- heldversion "$STORE" 2>/dev/null)" || S_SCHEMA=""\n')])
|
||
mut("M44", "^T24 ", [(' capture || refuse capture-failed "could not write the rollback set $RS; nothing was stopped"\n',
|
||
' capture || { echo "stack-release: refusing capture-failed: could not write the rollback set $RS; nothing was stopped" >&2; exit 3; }\n')])
|
||
mut("M45a", "^T25 ", [(' else refuse copies-unrelated "neither $P_COPY nor $TO is an ancestor of the other, so the plan cannot list the commits"\n',
|
||
' else RANGE="$P_COPY..$TO" VERB=adds\n')])
|
||
mut("M45b", "^T26 ", [(" plan_commits\n", "")])
|
||
mut("M46", "^T(26|23) ", [(' echo "migration: $S_SCHEMA to $T_SCHEMA, after a backup of the stopped store"\n', "")])
|
||
mut("M47", "^T(26|23|27) ", [(' echo "migration steps: $(plan_steps)"\n', "")])
|
||
mut("M48", "^T27 ", [(' (( ${#l[@]} % 2 == 0 )) || { echo "cannot be read from $f"; return; }\n', "")])
|
||
mut("M49", "^T27 ", [(' if [ "$v" = "$T_SCHEMA" ] && [ -n "$out" ]; then', ' if [ -n "$out" ]; then')])
|
||
|
||
def main():
|
||
only = set(sys.argv[1:])
|
||
os.makedirs(OUT, exist_ok=True)
|
||
pristine = {}
|
||
for f in (SR, SC):
|
||
p = f"{R}/edit/pristine-{os.path.basename(f)}"
|
||
shutil.copy2(f"{WT}/{f}", p)
|
||
if sha(p) != sha(f"{WT}/{f}"):
|
||
sys.exit(f"ABORT: backup of {f} failed")
|
||
pristine[f] = (p, sha(p))
|
||
env = dict(os.environ, TMPDIR=f"{R}/tmp")
|
||
results = []
|
||
try:
|
||
for mid, pattern, edits, f, expect in M:
|
||
if only and mid not in only:
|
||
continue
|
||
src = open(pristine[f][0]).read()
|
||
text = src
|
||
for e in edits:
|
||
old, new = e[0], e[1]
|
||
n = e[2] if len(e) > 2 else 1
|
||
if text.count(old) != n:
|
||
sys.exit(f"ABORT {mid}: expected {n} match(es) of {old!r} in {f}, found {text.count(old)}")
|
||
text = text.replace(old, new)
|
||
if text == src:
|
||
sys.exit(f"ABORT {mid}: no change")
|
||
if os.environ.get("DRY"):
|
||
print(f"{mid} ok", flush=True); continue
|
||
open(f"{WT}/{f}", "w").write(text)
|
||
log = f"{OUT}/{mid}.log"
|
||
t0 = time.time()
|
||
with open(log, "w") as fh:
|
||
p = subprocess.Popen(["node", "--test", "--test-reporter=spec", f"--test-name-pattern={pattern}", TEST],
|
||
cwd=WT, env=env, stdout=fh, stderr=subprocess.STDOUT, start_new_session=True)
|
||
try:
|
||
rc = p.wait(timeout=600)
|
||
except subprocess.TimeoutExpired:
|
||
os.killpg(p.pid, signal.SIGKILL); p.wait(); rc = "timeout"
|
||
shutil.copy2(pristine[f][0], f"{WT}/{f}")
|
||
if sha(f"{WT}/{f}") != pristine[f][1]:
|
||
sys.exit(f"ABORT {mid}: restore of {f} failed")
|
||
body = open(log).read()
|
||
ran = re.search(r"^ℹ tests (\d+)", body, re.M)
|
||
fails = re.search(r"^ℹ fail (\d+)", body, re.M)
|
||
nfail = int(fails.group(1)) if fails else -1
|
||
failed_names = re.findall(r"^\s*✖ (.+?) \(\d", body, re.M)
|
||
killed = rc != 0 and nfail > 0
|
||
if expect and killed:
|
||
killed = any(n == expect for n in failed_names)
|
||
verdict = "KILLED" if killed else "SURVIVED"
|
||
line = f"{mid} {verdict} rc={rc} tests={ran.group(1) if ran else '?'} fail={nfail} {time.time()-t0:.0f}s failed={sorted(set(failed_names))[:6]}"
|
||
print(line, flush=True)
|
||
results.append((mid, verdict))
|
||
finally:
|
||
for f, (p, s) in pristine.items():
|
||
shutil.copy2(p, f"{WT}/{f}")
|
||
if sha(f"{WT}/{f}") != s:
|
||
print(f"RESTORE FAILED {f}", flush=True)
|
||
surv = [m for m, v in results if v != "KILLED"]
|
||
print(f"DONE {len(results)} mutants, {len(results)-len(surv)} killed, survived: {surv}", flush=True)
|
||
sys.exit(1 if surv else 0)
|
||
|
||
main()
|