tokenfabrikker/tests/test_verktoy.py
Kjell Tore Guttormsen 6a51c4f4d2
feat(grunnlag): the approved EEA assessment as a fixed table, and M7 rejects a net present value that is not a number (clarifications 136 and 139)
fra_frys takes the assessment of clarification 136 («usikker» for all
four ownership forms) and has no guard any more; it is still not called
before part 6. beste_per_trekning raises on NaN, where the best would
depend on the order of the solutions.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-14 06:43:45 +01:00

485 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_henter_grunnlaget_fra_frysen(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
) -> None:
"""--frys asks for the basis from the freeze; the freeze itself is not read before part 6."""
kalt: list[tuple[object, ...]] = []
def fra_frys(*args: object) -> gl.Grunnlag:
kalt.append(args)
msg = "ikke lest i testen"
raise gl.GrunnlagError(msg)
monkeypatch.setattr(gl, "fra_frys", fra_frys)
assert vt.main(["hovedkjoring", "--frys", "--ut", str(tmp_path / "ut")]) == 2
assert "ikke lest i testen" in capsys.readouterr().err
assert kalt == [()]
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()
},
}