tokenfabrikker/tests/test_verktoy.py
Kjell Tore Guttormsen 5a54fba628
feat(dommer): the power solutions compared on equal terms, and the axes of the surfaces (clarifications 134, 135 and 137)
M7 gives, for each of the five solutions, the share of the draws in which it
is best alone and in which it shares the place, with no verdict on A; part II
and the thresholds for M7 are gone. T-F and T-K share the place where they
are the same path. The surfaces carry the classes along their axes, and
kontroll prints a line per file. The made-up reference files are
regenerated: everything outside the comparison is unchanged to the last
digit. Nothing is computed on the frozen parameters.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 23:03:05 +01:00

482 lines
19 KiB
Python

"""The tools of chapter 12 on the command line (chapter 16, clarifications 126 to 132).
A tiny made-up main run (the first draw of the made-up basis, the ladder 1, 2) is written
once and the tools are tried against it. Made-up numbers only; nothing here says anything about
the hypothesis. The full reproduction of the stored made-up reference in ``oppdiktet/fasit`` is
too slow for the suite and is run by hand (see ``oppdiktet/lag_grunnlag.py``); here only its
checksums are checked.
"""
from __future__ import annotations
import hashlib
import json
import shutil
from pathlib import Path
import pytest
from tokenfabrikker import datafiler as df
from tokenfabrikker import folsomheter as fs
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import kjoring as kj
from tokenfabrikker import verktoy as vt
from tokenfabrikker.utbygging import Losning
OPPDIKTET = Path(__file__).resolve().parent / "oppdiktet"
STIGE = (1, 2)
NORM = kj.SCENARIOER[1]
@pytest.fixture(scope="module")
def liten(tmp_path_factory: pytest.TempPathFactory) -> Path:
"""A basis file with the first made-up draw; one draw keeps the suite fast."""
data = json.loads((OPPDIKTET / "grunnlag.json").read_text(encoding="utf-8"))
data["trekninger"] = data["trekninger"][:1]
sti = tmp_path_factory.mktemp("grunnlag") / "grunnlag.json"
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return sti
@pytest.fixture(scope="module")
def hoved(liten: Path, tmp_path_factory: pytest.TempPathFactory) -> Path:
"""The tiny main run, written on one process through the command line."""
ut = tmp_path_factory.mktemp("hoved")
assert (
vt.main(["hovedkjoring", "--grunnlag", str(liten), "--ut", str(ut), "--stige", "1,2"]) == 0
)
return ut
def _les(sti: Path) -> dict[str, object]:
data: dict[str, object] = json.loads(sti.read_text(encoding="utf-8"))
return data
def _skriv_inngang(mappe: Path, data: object, navn: str = "inngang.json") -> str:
sti = mappe / navn
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return str(sti)
# ------------------------------------------------------------------ the main run
def test_hovedkjoringen_skriver_seks_filer_med_innholdsliste(hoved: Path, liten: Path) -> None:
assert sorted(p.name for p in hoved.iterdir()) == sorted(df.ALLE_FILER)
innhold = _les(hoved / "innhold.json")
assert innhold == {
"grunnlag": {
"merke": "oppdiktet",
"sjekksummer": {"grunnlagsfil": hashlib.sha256(liten.read_bytes()).hexdigest()},
},
"antall_trekninger": 1,
"stige": [1, 2],
"scenarioer": [s.navn for s in kj.SCENARIOER],
"losninger": [a.value for a in Losning],
"filer": {
navn: hashlib.sha256((hoved / navn).read_bytes()).hexdigest() for navn in df.FILER
},
}
for navn in df.FILER:
data = _les(hoved / navn)
assert {k: data[k] for k in list(innhold)[:5]} == {k: innhold[k] for k in list(innhold)[:5]}
def test_filene_har_formatet_og_ingen_avrunding(hoved: Path) -> None:
"""Every float reads back to the same float, and writing what was read gives the bytes."""
for navn in df.ALLE_FILER:
raa = (hoved / navn).read_bytes()
assert raa.endswith(b"\n")
assert not raa.endswith(b"\n\n")
assert b"\r" not in raa
assert b"\\u" not in raa
assert df.json_tekst(json.loads(raa)).encode("utf-8") == raa
def test_tallene_er_de_de_eksisterende_funksjonene_gir(hoved: Path, liten: Path) -> None:
g = gl.fra_fil(liten)
kjoring = kj.kjor(g.trekninger, stige=STIGE)
dommer = kj.sett_dommer(kjoring, g.M5, storrelser=g.storrelser, status=g.status)
lest = _les(hoved / "dommer.json")
assert (lest["trinn"], lest["grunnlag_for_trinnet"]) == (
dommer.valg.trinn,
dommer.valg.grunnlag.value,
)
assert lest == df.rein(
df.lag_dommer(df.hode(g, STIGE, kj.SCENARIOER, tuple(Losning)), kjoring, dommer)
)
per_scenario = lest["per_scenario"]
assert isinstance(per_scenario, list)
for blokk in per_scenario:
sd = dommer.scenarioer[blokk["navn"]]
for t in blokk["trinn"]:
for a in Losning:
for m in kj.MAAL_PER_LOSNING:
md = sd.per_trinn[t["trinn"]][a].maal[m]
assert t["losninger"][a.value][m]["dom"] == md.dom.value
assert t["losninger"][a.value][m]["andel_holder"] == md.andel_holder
assert dommer.valg.trinn is not None
trinn = dommer.valg.trinn
# the timeline
tidslinje = _les(hoved / "tidslinje.json")
per_losning = tidslinje["per_losning"]
assert isinstance(per_losning, dict)
alle = kj.tidslinje_over_trekningene(kjoring, Losning.T_K, 2)["alle"]
assert [r["median"] for r in per_losning["T-K"][1]["typer"]["alle"]] == [x.median for x in alle]
# the sensitivity list: the main run's row and one row through kjor_rad
folsomheter = _les(hoved / "folsomheter.json")
hovedkjoringen = folsomheter["hovedkjoringen"]
assert isinstance(hovedkjoringen, dict)
assert list(hovedkjoringen) == [s.navn for s in kj.SCENARIOER if s.navn != "overkapasitet"]
assert hovedkjoringen["normalisering"] == df.rein(
df.radtabell(fs.hovedtabell(kjoring, g.M5, dommer.valg, NORM))
)
rad = fs.RADER["14"]
radkjoring = fs.kjor_rad(g.trekninger, rad, dommer.valg, karbonbaner=g.karbonbaner)
rader = folsomheter["rader"]
assert isinstance(rader, dict)
assert list(rader) == list(fs.RADER)
assert rader["14"]["tabell"]["normalisering"] == df.rein(
df.radtabell(fs.tabell(kjoring, rad, radkjoring, g.M5, dommer.valg)["normalisering"])
)
assert rader["10"]["merknad"] == fs.MERKNAD_STANDARDVILKAAR
assert rader["24"]["tabell"] is None
assert set(rader["24"]["eierformer"]) == {"A", "B", "C", "T-F", "T-K"}
# the price threshold, its check and d*
terskler = _les(hoved / "terskler.json")
p = kj.pristerskel_for_losning(g.trekninger, Losning.C, trinn, NORM)
pris = terskler["pristerskler"]
assert isinstance(pris, dict)
assert pris["C"]["normalisering"]["k"] == p.k
assert list(pris["C"]) == ["knapphet varer", "normalisering", "overkapasitet"]
stjerne = terskler["d_stjerne"]
assert isinstance(stjerne, dict)
assert stjerne["C"]["k_a"] == p.k
assert [x["eps_d"] for x in stjerne["C"]["verdier"]] == [1.0, 0.5, 2.0]
# the ownership forms
eier = _les(hoved / "eierformer.json")
tabeller = kj.eierformer_paa_trinnet(g.trekninger, dommer.valg, g.eos)
per_losning = eier["per_losning"]
assert isinstance(per_losning, dict)
assert per_losning == {a.value: df.rein(df.eierformtabell(tabeller[a])) for a in tabeller}
def test_kontroll_med_to_prosesser_er_identisk(
hoved: Path, liten: Path, capsys: pytest.CaptureFixture[str]
) -> None:
"""Clarification 129 and 101: the same bytes on two processes as on one."""
kode = vt.main(
["kontroll", "--grunnlag", str(liten), "--fasit", str(hoved), "--prosesser", "2"]
)
ut = capsys.readouterr().out
assert kode == 0
for navn in df.ALLE_FILER:
assert f"{navn}: identisk\n" in ut
assert "Samlet: identisk (største relative avvik 0). Grunnlaget er merket «oppdiktet»." in ut
# a line per file as it is made, in the order they are made, before the verdicts (134)
linjer = ut.splitlines()
assert linjer[: len(df.ALLE_FILER)] == [f"Laget {navn}" for navn in df.ALLE_FILER]
def test_kontroll_sier_endret_og_gir_feilkode(
hoved: Path,
liten: Path,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
capsys: pytest.CaptureFixture[str],
) -> None:
"""A changed verdict in a file made anew is «endret», with exit code 1."""
def kopier_og_endre(_: object, ny: Path, **__: object) -> tuple[str, ...]:
shutil.copytree(hoved, ny, dirs_exist_ok=True)
data = _les(ny / "dommer.json")
data["del_I"] = "holder"
df.skriv(ny / "dommer.json", data)
return df.ALLE_FILER
monkeypatch.setattr(df, "skriv_hovedkjoring", kopier_og_endre)
kode = vt.main(
["kontroll", "--grunnlag", str(liten), "--fasit", str(hoved), "--ut", str(tmp_path / "ny")]
)
ut = capsys.readouterr().out
assert kode == 1
assert "dommer.json: endret; første forskjell: $.del_I: 'holder' mot" in ut
assert "Samlet: endret" in ut
# ------------------------------------------------------------- the four tools
def _uten_verktoy(sti: Path) -> bytes:
data = _les(sti)
verktoy = data["verktoy"]
assert isinstance(verktoy, dict)
assert verktoy["setning"] == vt.SETNING
del data["verktoy"]
return df.json_tekst(data).encode("utf-8")
def test_et_scenario_uten_endringer_gir_hovedkjoringens_filer(
hoved: Path, liten: Path, tmp_path: Path
) -> None:
"""Clarification 130: byte for byte, apart from what the tool adds."""
inngang = _skriv_inngang(tmp_path, {"navn": "uendret", "stige": [2, 1]})
ut = tmp_path / "ut"
assert vt.main(["scenario", inngang, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
for navn in (df.DOMMER, df.TIDSLINJE):
assert _uten_verktoy(ut / navn) == (hoved / navn).read_bytes()
assert next(iter(_les(ut / navn))) == "verktoy"
assert _les(ut / df.DOMMER)["verktoy"] == {
"setning": "Egen kjøring: ingen dom her er rapportens dom",
"kommando": "scenario",
"inngang": {"navn": "uendret", "stige": [2, 1]},
}
def test_scenario_med_egne_verdier_og_sammenlign(hoved: Path, liten: Path, tmp_path: Path) -> None:
inngang = {
"navn": "dyr reaktor",
"verdier": {"c_N_ref": 150000},
"losninger": ["C", "A"],
"stige": [1],
"scenarioer": ["normalisering"],
"trekninger": 1,
}
ut = tmp_path / "ut"
sti = _skriv_inngang(tmp_path, inngang)
assert vt.main(["scenario", sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
dommer = _les(ut / df.DOMMER)
assert dommer["verktoy"] == {"setning": vt.SETNING, "kommando": "scenario", "inngang": inngang}
assert (dommer["antall_trekninger"], dommer["stige"], dommer["losninger"]) == (
1,
[1],
["A", "C"],
)
sammen = tmp_path / "sammen"
assert vt.main(["sammenlign", str(hoved), str(ut), "--ut", str(sammen)]) == 0
s = _les(sammen / "sammenligning.json")
assert list(s) == ["verktoy", "ulikt_grunnlag", "a", "b", "trinnet", "per_scenario"]
assert s["ulikt_grunnlag"] == []
# sammenlign computes nothing: a folder from another basis with more draws is said first
annen = tmp_path / "annen"
annen.mkdir()
dommer["antall_trekninger"] = 5
dommer["grunnlag"] = {"merke": "oppdiktet", "sjekksummer": {"grunnlagsfil": "0"}}
df.skriv(annen / df.DOMMER, dommer)
assert vt.main(["sammenlign", str(hoved), str(annen), "--ut", str(sammen)]) == 0
s = _les(sammen / "sammenligning.json")
assert s["ulikt_grunnlag"] == [
"De to er laget fra ulikt grunnlag.",
"De to har ulikt antall trekninger: 1 og 5.",
]
per_scenario = s["per_scenario"]
assert isinstance(per_scenario, dict)
assert list(per_scenario) == ["normalisering"]
trinn = per_scenario["normalisering"]["trinn"]
assert [t["trinn"] for t in trinn] == [1]
assert list(trinn[0]["losninger"]) == ["A", "C"]
m1 = trinn[0]["losninger"]["A"]["M1"]
assert list(m1) == ["a", "b", "endring_andel_holder"]
# the comparison in M7 for the solutions both have, then «delt» and «ingen»; no part II
m7 = trinn[0]["M7"]
assert list(m7) == ["A", "C", "delt", "ingen"]
for x in m7.values():
assert list(x) == ["a", "b", "endring"]
assert x["endring"] == x["b"] - x["a"]
assert list(per_scenario["normalisering"]) == ["trinn", "del_I"]
median = trinn[0]["losninger"]["A"]["median_M1"]
if median["a"] is not None and median["b"] is not None:
assert median["endring"] == median["b"] - median["a"]
a, b = s["a"], s["b"]
assert isinstance(a, dict)
assert isinstance(b, dict)
assert (a["egen_kjoring"], b["egen_kjoring"]) == (False, True)
def test_folsomhet_med_alle_rader_gir_hovedkjoringens_fil(
hoved: Path, liten: Path, tmp_path: Path
) -> None:
sti = _skriv_inngang(tmp_path, {})
ut = tmp_path / "ut"
kode = vt.main(
[
"folsomhet",
sti,
"--grunnlag",
str(liten),
"--ut",
str(ut),
"--stige",
"1,2",
"--prosesser",
"2",
]
)
assert kode == 0
assert _uten_verktoy(ut / df.FOLSOMHETER) == (hoved / df.FOLSOMHETER).read_bytes()
def test_terskel_for_en_losning(hoved: Path, liten: Path, tmp_path: Path) -> None:
terskler = _les(hoved / "terskler.json")
trinn = terskler["trinn"]
sti = _skriv_inngang(tmp_path, {"losning": "C", "trinn": trinn})
ut = tmp_path / "ut"
assert vt.main(["terskel", sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
t = _les(ut / "terskel.json")
pris = terskler["pristerskler"]
assert isinstance(pris, dict)
assert t["pristerskel"] == pris["C"]["normalisering"]
assert t["d_stjerne"] == terskler["d_stjerne"]["C"]["verdier"] # type: ignore[index]
assert t["median_lcoc_v_2025"] == terskler["median_lcoc_v_2025"]
sti = _skriv_inngang(tmp_path, {"losning": "C", "trinn": trinn, "scenario": "knapphet varer"})
assert vt.main(["terskel", sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
t = _les(ut / "terskel.json")
assert t["pristerskel"] == pris["C"]["knapphet varer"]
assert t["d_stjerne"] is None
# ------------------------------------------------------------- strict input files
@pytest.mark.parametrize(
("kommando", "inngang", "melding"),
[
("scenario", {"navn": "x", "ekstra": 1}, "inngangsfila: ukjent felt: ekstra"),
("scenario", {"stige": [1]}, "inngangsfila: feltet mangler: navn"),
("scenario", {"navn": "x", "stige": "1,2"}, "stige: skal være en liste"),
("scenario", {"navn": "x", "trekninger": 1.0}, "trekninger: skal være et heltall"),
("scenario", {"navn": "x", "losninger": ["D"]}, "losninger: ukjent løsning 'D'"),
(
"scenario",
{"navn": "x", "scenarioer": ["tørrår"]},
"scenarioer: ukjent scenario 'tørrår'",
),
("scenario", {"navn": "x", "scenarioer": ["overkapasitet"]}, "«normalisering» må være med"),
(
"scenario",
{"navn": "x", "verdier": {"c_N_reff": 1.0}},
"verdier: ukjent størrelse c_N_reff",
),
(
"scenario",
{"navn": "x", "verdier": {"c_N_ref": "1"}},
"verdier.c_N_ref: skal være et tall",
),
("scenario", {"navn": "x", "trekninger": 3}, "grunnlaget har 1 trekninger, ba om 3"),
("folsomhet", {"rader": ["38"]}, "rader: ukjent rad 38"),
("folsomhet", {"rader": ["14", "14"]}, "rader: står to ganger: 14"),
("terskel", {"losning": "C"}, "inngangsfila: feltet mangler: trinn"),
(
"terskel",
{"losning": "C", "trinn": 2, "scenario": "kildenes lave forlop"},
"ukjent scenario",
),
("terskel", {"losning": "Q", "trinn": 2}, "losning: ukjent løsning 'Q'"),
],
)
def test_inngangsfila_leses_strengt_og_stanser_foer_noe_regnes(
liten: Path,
tmp_path: Path,
capsys: pytest.CaptureFixture[str],
kommando: str,
inngang: object,
melding: str,
) -> None:
sti = _skriv_inngang(tmp_path, inngang)
ut = tmp_path / "ut"
assert vt.main([kommando, sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 2
assert melding in capsys.readouterr().err
assert not ut.exists()
def test_frysen_stanser_ved_vakten(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
"""Clarification 127: until the EEA assessment is written down, --frys stops at once."""
sti = _skriv_inngang(tmp_path, {"navn": "x"})
for argumenter in (
["scenario", sti, "--frys", "--ut", str(tmp_path / "ut")],
["hovedkjoring", "--frys", "--ut", str(tmp_path / "ut")],
):
assert vt.main(argumenter) == 2
assert (
"EØS-vurderingen per eierform er ikke fastsatt (avklaring 127)"
in capsys.readouterr().err
)
assert not (tmp_path / "ut").exists()
def test_grunnlaget_maa_oppgis_paa_en_maate(tmp_path: Path, liten: Path) -> None:
sti = _skriv_inngang(tmp_path, {"navn": "x"})
for argumenter in (
["scenario", sti, "--ut", str(tmp_path)],
["scenario", sti, "--frys", "--grunnlag", str(liten), "--ut", str(tmp_path)],
):
with pytest.raises(SystemExit) as feil:
vt.main(argumenter)
assert feil.value.code == 2
def test_hovedkjoring_kjenner_bare_de_fem_filene(
liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
kode = vt.main(
[
"hovedkjoring",
"--grunnlag",
str(liten),
"--ut",
str(tmp_path),
"--filer",
"resultat.json",
]
)
assert kode == 2
assert "--filer: ukjent fil resultat.json" in capsys.readouterr().err
# ------------------------------------------------------------------ the working copy
def test_arbeidskopien(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
kopi = tmp_path / "kopi"
assert vt.main(["arbeidskopi", str(kopi)]) == 0
for sti in (
"src/tokenfabrikker/verktoy.py",
"tests/test_verktoy.py",
"tests/oppdiktet/grunnlag.json",
"modell/parametere.json",
"modell/spesifikasjon.md",
"data/trekninger.npy",
"data/aarshendelser.json",
"requirements.txt",
"requirements-dev.txt",
"pyproject.toml",
):
assert (kopi / sti).is_file(), sti
assert (kopi / sti).read_bytes() == (vt.ROT / sti).read_bytes()
assert not list(kopi.rglob("__pycache__"))
tekst = (kopi / "ARBEIDSKOPI.md").read_text(encoding="utf-8")
sjekksum = hashlib.sha256((vt.ROT / "modell" / "parametere.json").read_bytes()).hexdigest()
assert f"SHA-256 for parameterfila ved kopieringen: `{sjekksum}`" in tekst
assert "Ingenting i en arbeidskopi er rapportens tall." in tekst
assert "Parameterfila var den frosne." in tekst
capsys.readouterr()
assert vt.main(["arbeidskopi", str(kopi)]) == 2
assert "finnes og er ikke en tom mappe" in capsys.readouterr().err
# ------------------------------------------------------------ the stored reference
def test_den_oppdiktede_fasiten_har_sjekksummene_i_innholdslista() -> None:
fasit = OPPDIKTET / "fasit"
innhold = _les(fasit / "innhold.json")
assert innhold["filer"] == {
navn: hashlib.sha256((fasit / navn).read_bytes()).hexdigest() for navn in df.FILER
}
assert innhold["grunnlag"] == {
"merke": "oppdiktet",
"sjekksummer": {
"grunnlagsfil": hashlib.sha256((OPPDIKTET / "grunnlag.json").read_bytes()).hexdigest()
},
}