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>
485 lines
19 KiB
Python
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()
|
|
},
|
|
}
|