"""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 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"] 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() }, }