Test først, så kode

"""Testene for tempo(). Skrevet før koden, fra spesifikasjon.md.

Kjør fra denne mappa:  python -m unittest -v

Hver test har navn etter regelen den sjekker, slik at en feilmelding sier
hva som er brutt, ikke bare hvor.
"""
import unittest

from tempo import tempo


class TestTempo(unittest.TestCase):

    def test_hele_minutter(self):
        self.assertEqual(tempo(5, "25:00"), "5:00")

    def test_runder_til_naermeste_sekund(self):
        self.assertEqual(tempo(10, "47:03"), "4:42")

    def test_timer_i_tida(self):
        self.assertEqual(tempo(10, "1:02:30"), "6:15")

    def test_sekunder_runder_opp_til_nytt_minutt(self):
        # 14:59 på 3 km er 4:59,67 per km. Det skal bli 5:00, ikke 4:60.
        self.assertEqual(tempo(3, "14:59"), "5:00")

    def test_null_distanse_gir_feil(self):
        with self.assertRaises(ValueError):
            tempo(0, "10:00")


if __name__ == "__main__":
    unittest.main()

{
  "permissions": {
    "deny": [
      "Edit(**/test_*.py)",
      "Edit(tests/**)",
      "Edit(**/tester.laas)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write|Bash",
        "hooks": [
          {
            "type": "command",
            "command": "python \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/hook_vern_tester.py"
          }
        ]
      }
    ]
  }
}

"""PreToolUse-hook for Claude Code: stopper endringer i testene og i låsfila.

Claude Code sender en JSON på standard inn før verktøyet kjøres. Avslutter
skriptet med kode 2, blokkeres kallet, og teksten på standard feil går
tilbake til Claude som forklaring. Kode 1 ville IKKE stoppet noe:
dokumentasjonen sier at Claude Code regner alt annet enn 2 som en feil som
ikke blokkerer, og går videre. Slik står det i code.claude.com/docs/en/hooks,
lest 9. oktober 2026.

Legg fila i .claude/hooks/ og registrer den i en egen innstillingsfil, se
eksempel-settings.json i samme mappe. Den egne fila er et valg: økta som
skal skrive testene, må kunne skrive dem, og starter derfor uten den.

Hva den dekker:
  - Edit og Write mot test_*.py, alt under en mappe som heter tests
    (uansett store og små bokstaver), og låsfila tester.laas
  - Bash-kommandoer som nevner tester.laas eller kjører «laas.py lag»

Hva den ikke dekker: Bash-sjekken er ren tekstsammenligning, og et skript
agenten skriver og kjører selv, går rett forbi. Den er en fartsdump mot
snarveien, ikke en mur. Det som holder, er at endringer i testene og i
tester.laas må godkjennes av et menneske før de kommer inn, se
test-forst-med-ai.html.
"""
import json
import pathlib
import sys

sys.stderr.reconfigure(encoding="utf-8")
data = json.load(sys.stdin)
verktoy = data.get("tool_name", "")
inn = data.get("tool_input") or {}


def er_vernet(sti: str) -> bool:
    # Windows sender stien med omvendt skråstrek. Normaliser før sammenligning,
    # og se bort fra store og små bokstaver, ellers slipper Tests\ forbi.
    sti = sti.replace("\\", "/").lower()
    navn = pathlib.PurePosixPath(sti).name
    deler = pathlib.PurePosixPath(sti).parts[:-1]
    return ((navn.startswith("test_") and navn.endswith(".py"))
            or navn == "tester.laas"
            or "tests" in deler)


def stopp(grunn: str) -> None:
    print(f"Blokkert: {grunn} Rett koden, ikke testen. "
          "Mener du at testen er feil, si det til brukeren og stopp.", file=sys.stderr)
    sys.exit(2)


if verktoy in ("Edit", "Write"):
    sti = inn.get("file_path", "")
    if er_vernet(sti):
        navn = sti.replace("\\", "/").rsplit("/", 1)[-1]
        stopp(f"{navn} er låst.")

if verktoy == "Bash":
    kommando = inn.get("command", "").lower()
    if "tester.laas" in kommando or ("laas.py" in kommando and " lag" in kommando):
        stopp("Låsen på testene lages av et menneske, ikke av deg.")

sys.exit(0)

"""Låser testfilene med et fingeravtrykk (SHA-256).

    python laas.py lag   [mappe]   skriver tester.laas, gjøres av et menneske
    python laas.py sjekk [mappe]   feiler (exit 1) hvis en testfil er endret

Mappa er der testene ligger. Uten mappe brukes mappa laas.py ligger i.
Alle test_*.py under mappa tas med, også i undermapper, og tester.laas
skrives i mappa.

Hvorfor et fingeravtrykk og ikke bare en instruks: en agent som skal få
testene grønne, har to veier. Den kan rette koden, eller den kan rette
testen. En setning i en prompt ber den la være. Denne sjekken merker det
hvis den ikke gjorde det.

Hva den ikke beskytter mot: tester.laas ligger i samme repo som testene.
Den som kan endre testene, kan også kjøre «laas.py lag» og committe en ny
lås sammen med den endrede testen, og da går sjekken grønn. Låsen er bare
så sterk som kravet om at et menneske godkjenner endringer i tester.laas,
for eksempel med CODEOWNERS og grenbeskyttelse i GitHub. Uten det fanger
den uhell og snarveier, ikke en som er bestemt på å gå rundt.

Linjeskift normaliseres før hashing. Ellers ville git på Windows, som
gjerne bytter LF til CRLF, se ut som en endring av testene.
"""
import hashlib
import pathlib
import sys

MAPPE = pathlib.Path(__file__).parent


def fingeravtrykk(fil: pathlib.Path) -> str:
    innhold = fil.read_bytes().replace(b"\r\n", b"\n")
    return hashlib.sha256(innhold).hexdigest()


def testfiler(mappe: pathlib.Path) -> dict:
    # Relativ sti med skråstrek, så låsfila blir lik på Windows og Linux.
    return {f.relative_to(mappe).as_posix(): f for f in sorted(mappe.rglob("test_*.py"))}


def lag(mappe: pathlib.Path = MAPPE) -> None:
    filer = testfiler(mappe)
    linjer = [f"{fingeravtrykk(f)}  {navn}" for navn, f in filer.items()]
    (mappe / "tester.laas").write_text("\n".join(linjer) + "\n", encoding="utf-8", newline="\n")
    print(f"Låste {len(linjer)} testfil(er) i tester.laas")


def sjekk(mappe: pathlib.Path = MAPPE, laasfil: pathlib.Path | None = None) -> int:
    laasfil = laasfil or mappe / "tester.laas"
    if not laasfil.exists():
        print(f"FEIL: finner ikke {laasfil}. Lag låsen først: python laas.py lag")
        return 1
    laast = {}
    for linje in laasfil.read_text(encoding="utf-8").splitlines():
        if linje.strip():
            hash_, navn = linje.split(maxsplit=1)
            laast[navn] = hash_
    naa = {navn: fingeravtrykk(f) for navn, f in testfiler(mappe).items()}

    feil = []
    for navn, hash_ in laast.items():
        if navn not in naa:
            feil.append(f"{navn} er slettet")
        elif naa[navn] != hash_:
            feil.append(f"{navn} er endret siden testene ble låst")
    for navn in sorted(naa.keys() - laast.keys()):
        feil.append(f"{navn} er ny og ikke låst")

    if feil:
        for f in feil:
            print("FEIL:", f)
        print("Testene er låst. Endringer i dem må godkjennes av et menneske.")
        return 1
    print(f"OK: {len(laast)} testfil(er) uendret")
    return 0


if __name__ == "__main__":
    sys.stdout.reconfigure(encoding="utf-8")
    kommando = sys.argv[1] if len(sys.argv) > 1 else ""
    mappe = pathlib.Path(sys.argv[2]) if len(sys.argv) > 2 else MAPPE
    if kommando == "lag":
        lag(mappe)
    elif kommando == "sjekk":
        sys.exit(sjekk(mappe))
    else:
        print(__doc__)
        sys.exit(2)