tokenfabrikker/tests/test_grunnlag.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

256 lines
9.7 KiB
Python

"""The basis of a run (chapter 12; chapter 16, clarification 127).
Made-up numbers only: the made-up basis file in ``tests/oppdiktet`` and variants of it. The
basis from the freeze is only tried up to its guard: until the EEA assessment per ownership
form is written down, it stops before it reads anything.
"""
from __future__ import annotations
import json
import re
from pathlib import Path
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import parametere
from tokenfabrikker.dommer import Dom
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Callable
GRUNNLAGSFIL = Path(__file__).resolve().parent / "oppdiktet" / "grunnlag.json"
@pytest.fixture(scope="module")
def grunnlag() -> gl.Grunnlag:
return gl.fra_fil(GRUNNLAGSFIL)
def _raa() -> dict[str, object]:
data: dict[str, object] = json.loads(GRUNNLAGSFIL.read_text(encoding="utf-8"))
return data
def _skriv(tmp_path: Path, data: object) -> Path:
sti = tmp_path / "grunnlag.json"
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return sti
def test_grunnlagsfila_er_merket_oppdiktet_med_sin_sjekksum(grunnlag: gl.Grunnlag) -> None:
import hashlib # noqa: PLC0415
assert grunnlag.merke == "oppdiktet"
assert grunnlag.sjekksummer == {
"grunnlagsfil": hashlib.sha256(GRUNNLAGSFIL.read_bytes()).hexdigest()
}
assert grunnlag.merkelapp == {"merke": "oppdiktet", "sjekksummer": dict(grunnlag.sjekksummer)}
assert grunnlag.antall >= 40
assert set(grunnlag.M5) == set(Losning)
assert grunnlag.M5[Losning.C] is Dom.HOLDER
assert set(grunnlag.karbonbaner) == {"lav", "hoy"}
def test_trukne_verdier_i_filas_enhet_og_tallsettet_i_ligningenes(grunnlag: gl.Grunnlag) -> None:
"""c_N_ref stands in kr/kW in the file, and in kr/MW in the equations."""
raa = _raa()
storrelser = raa["storrelser"]
assert isinstance(storrelser, list)
trukne = [s["navn"] for s in storrelser if s["verdi"] is None]
assert list(grunnlag.storrelser) == trukne
assert list(grunnlag.status) == trukne
assert grunnlag.faktorer["c_N_ref"] == 1000.0
for omega, inn in enumerate(grunnlag.trekninger):
assert inn["c_N_ref"] == grunnlag.storrelser["c_N_ref"][omega] * 1000.0
assert inn["y_obs"] == grunnlag.storrelser["y_obs"][omega] * 1e6
assert inn["eps_d"] == grunnlag.eps_d
assert len(inn.u_eksport) == round(inn["T_slutt"] - inn["T0"])
assert grunnlag.y_obs_maks == 229e6
assert all(len(x) == grunnlag.antall for x in grunnlag.storrelser.values())
def test_de_forste_N_trekningene(grunnlag: gl.Grunnlag) -> None:
tre = grunnlag.de_forste(3)
assert tre.trekninger == grunnlag.trekninger[:3]
assert tre.storrelser["p_v"] == grunnlag.storrelser["p_v"][:3]
assert tre.sjekksummer == grunnlag.sjekksummer
for feil in (0, grunnlag.antall + 1):
with pytest.raises(gl.GrunnlagError, match="antall trekninger"):
grunnlag.de_forste(feil)
def test_faste_verdier_settes_etter_trekningen_i_filas_enhet(grunnlag: gl.Grunnlag) -> None:
"""Clarification 130: a fixed value in the file's unit, set after the draw (116)."""
med = grunnlag.med_verdier({"c_N_ref": 90_000.0, "eps_d": 0.5})
for gammel, ny in zip(grunnlag.trekninger, med.trekninger, strict=True):
assert ny["c_N_ref"] == 90e6
assert ny["eps_d"] == 0.5
assert ny["p_v"] == gammel["p_v"]
assert ny.med({"c_N_ref": gammel["c_N_ref"], "eps_d": gammel["eps_d"]}) == gammel
# the table of drawn values keeps the drawn values
assert med.storrelser == grunnlag.storrelser
assert med.eps_d == 0.5
assert grunnlag.med_verdier({}) is grunnlag
with pytest.raises(gl.GrunnlagError, match="ukjent størrelse: finnes_ikke"):
grunnlag.med_verdier({"finnes_ikke": 1.0})
def test_EOS_vurderingen_er_usikker_for_alle_fire_eierformene(grunnlag: gl.Grunnlag) -> None:
"""Clarification 136, approved 2026-11-14: no form is taken out and none is told apart."""
assert dict(gl.EOS_VURDERING) == {
"direkte": "usikker",
"heleid_selskap": "usikker",
"majoritet_boers": "usikker",
"petroleumsmodell": "usikker",
}
assert set(gl.EOS_VURDERING) == set(grunnlag.eos)
assert set(gl.EOS_VURDERING.values()) <= set(gl.EOS_VURDERINGER)
def test_grunnlaget_fra_frysen_har_ingen_sperre_og_leser_filene_det_faar() -> None:
"""The guard of clarification 127 is gone; with files that do not exist nothing is read."""
with pytest.raises(FileNotFoundError):
gl.fra_frys(parametere=Path("/finnes/ikke.json"), data=Path("/finnes/ikke"))
def test_den_frosne_sjekksummen_er_den_i_parameterkoden() -> None:
assert gl.FROSSEN_SJEKKSUM == parametere.FROSSEN_SHA256
def _uten(felt: str) -> Callable[[dict[str, object]], None]:
def endre(data: dict[str, object]) -> None:
del data[felt]
return endre
def _sett(felt: str, *args: object, verdi: object = None) -> Callable[[dict[str, object]], None]:
ny = args[0] if args else verdi
def endre(data: dict[str, object]) -> None:
data[felt] = ny
return endre
def _forste_trekning(endring: Callable[[dict[str, object]], object]) -> Callable[..., None]:
def endre(data: dict[str, object]) -> None:
trekninger = data["trekninger"]
assert isinstance(trekninger, list)
endring(trekninger[0])
return endre
def _forste_storrelse(endring: Callable[[dict[str, object]], object]) -> Callable[..., None]:
def endre(data: dict[str, object]) -> None:
storrelser = data["storrelser"]
assert isinstance(storrelser, list)
endring(storrelser[0])
return endre
@pytest.mark.parametrize(
("endring", "melding"),
[
(_sett("ekstra", 1), "grunnlagsfila: ukjent felt: ekstra"),
(_uten("eos"), "grunnlagsfila: feltet mangler: eos"),
(_sett("merke", "frosset"), "merke: en grunnlagsfil skal være merket 'oppdiktet'"),
(_sett("y_obs_maks", "229"), "y_obs_maks: skal være et tall"),
(_sett("y_obs_maks", verdi=True), "y_obs_maks: skal være et tall"),
(_sett("trekninger", []), "trekninger: skal ha minst én trekning"),
(_sett("M5", {"A": "holder"}), "M5: feltet mangler: B"),
(_sett("eos", {"direkte": "består"}), "eos: feltet mangler: heleid_selskap"),
(
_forste_trekning(lambda t: t.update(verdier=[1.0])),
"trekninger[0].verdier: skal ha 16 tall, har 1",
),
(
_forste_trekning(lambda t: t.pop("u_eksport")),
"trekninger[0]: feltet mangler: u_eksport",
),
(
_forste_trekning(lambda t: t.update(u_eksport=["0.5"])),
"trekninger[0].u_eksport[0]: skal være et tall",
),
(
_forste_storrelse(lambda s: s.update(status="kanskje")),
"storrelser[0].status: ukjent status 'kanskje'",
),
(
_forste_storrelse(lambda s: s.update(faktor=0.0)),
"storrelser[0].faktor: skal være positiv",
),
(_forste_storrelse(lambda s: s.update(enhet="år")), "storrelser[0]: ukjent felt: enhet"),
],
)
def test_grunnlagsfila_leses_strengt(
tmp_path: Path, endring: Callable[[dict[str, object]], None], melding: str
) -> None:
data = _raa()
endring(data)
with pytest.raises(gl.GrunnlagError, match=re.escape(melding)):
gl.fra_fil(_skriv(tmp_path, data))
def test_ukjent_dom_i_M5_og_ukjent_vurdering_i_EOS(tmp_path: Path) -> None:
data = _raa()
m5 = data["M5"]
assert isinstance(m5, dict)
m5["A"] = "holder kanskje"
with pytest.raises(gl.GrunnlagError, match=re.escape("M5.A: ukjent dom 'holder kanskje'")):
gl.fra_fil(_skriv(tmp_path, data))
data = _raa()
eos = data["eos"]
assert isinstance(eos, dict)
eos["direkte"] = "ja"
with pytest.raises(gl.GrunnlagError, match=re.escape("eos.direkte: ukjent vurdering 'ja'")):
gl.fra_fil(_skriv(tmp_path, data))
def test_tabellene_leses_strengt(tmp_path: Path) -> None:
data = _raa()
tabeller = data["tabeller"]
assert isinstance(tabeller, dict)
tabeller["bortfall"] = {"lavt": [0.1, 0.2]}
with pytest.raises(gl.GrunnlagError, match=re.escape("tabeller.bortfall: ukjent felt: lavt")):
gl.fra_fil(_skriv(tmp_path, data))
data = _raa()
tabeller = data["tabeller"]
assert isinstance(tabeller, dict)
tabeller["karbonpris"] = {"to tusen": 1.0}
with pytest.raises(gl.GrunnlagError, match="nøkkelen skal være et årstall"):
gl.fra_fil(_skriv(tmp_path, data))
def test_et_felt_to_ganger_og_tall_JSON_ikke_tillater_er_feil(tmp_path: Path) -> None:
sti = tmp_path / "grunnlag.json"
sti.write_text('{"merke": "oppdiktet", "merke": "oppdiktet"}', encoding="utf-8")
with pytest.raises(gl.GrunnlagError, match="feltet 'merke' står to ganger"):
gl.fra_fil(sti)
sti.write_text('{"y_obs_maks": NaN}', encoding="utf-8")
with pytest.raises(gl.GrunnlagError, match="NaN er ikke et tall JSON tillater"):
gl.fra_fil(sti)
def test_rho_N_trukket_krever_rho_D_trukket(tmp_path: Path) -> None:
"""Clarification 115 c: a threshold in rho_N is read in the two halves by rho_D."""
data = _raa()
storrelser = data["storrelser"]
trekninger = data["trekninger"]
assert isinstance(storrelser, list)
assert isinstance(trekninger, list)
trukne = [s["navn"] for s in storrelser if s["verdi"] is None]
i = trukne.index("rho_D")
for s in storrelser:
if s["navn"] == "rho_D":
s["verdi"] = 0.08
for t in trekninger:
del t["verdier"][i]
with pytest.raises(gl.GrunnlagError, match="trenger de trukne verdiene av rho_D"):
gl.fra_fil(_skriv(tmp_path, data))