Aislo/resources/tester/test_m02_hopyo_ledger.py

"""일위대가 실무자료 별칭 장부(PLAN 338-3 · `M02_Hopyo_Ledger`) — 옛 꼴 바꿔 읽음 · 새 꼴 ·
층 차례(아래 층이 이김) · 느슨 찾기(규격다름) · 우리에 없음 · 안 씀 · 호표 통째 열쇠 ·
위 층 읽기만 · 재검사 · 쓰기(처음파일 둠 · 옛 꼴 새로 씀) · master_data 원본 그대로. 층은 임시 폴더.
"""

import json

import pytest

from M02_MasterTemplete import M02_Hopyo_Ledger as ledger
from M02_MasterTemplete import M02_Hopyo_Match as hm
from M02_MasterTemplete import M02_Hopyo_Store as hs
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers

# 올리기 길 시험의 `client` 마당을 같이 씀
# ruff: noqa: F811
from resources.tester.test_m02_hopyo_excel import client, master_hash  # noqa: F401

DIG = {"이름": "구조물터파기(인력100%)", "규격": "토사", "단위": "㎥"}
DIG_KEY = "구조물터파기(인력100%)|토사|m3"
WHO = {"id": 42, "이름": "갑"}


def _put_raw(folder, rows):
    path = folder / hs.DIRNAME / f"{hs.MEMORY}.json"
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps({"줄": rows}, ensure_ascii=False), encoding="utf-8")


def _raw(folder):
    return json.loads((folder / hs.DIRNAME / f"{hs.MEMORY}.json").read_bytes())["줄"]


def test_열쇠는_맞춤과_같음():
    assert ledger.key(DIG) == hm.line_key(DIG) == DIG_KEY
    assert ledger.hopyo_key(DIG) == "호표|" + DIG_KEY
    assert ledger._loose(DIG_KEY) == "구조물터파기(인력100%)|m3"
    assert ledger._loose("호표|" + DIG_KEY) == "호표|구조물터파기(인력100%)|m3"


def test_옛_꼴_바꿔_읽음(client):
    mine = layers.personal_dir(7, 42)
    _put_raw(
        mine,
        {
            DIG_KEY: {"로직": "GF000101", "입력값": {"지역": "서울"}, "환산": 2, "확정": "t1"},
            "합판거푸집|4회|m2": {"빼기": True, "확정": "2026-10-02T10:00:00"},
            "표지석||개": {"자재": "MT004258", "입력값": {}, "환산": 1, "확정": "t"},
            "깨진|줄": {"로직": "X"},
            "빈|짝|m": {"입력값": {}},
        },
    )  # fmt: skip
    got = ledger.read(mine)
    assert set(got) == {DIG_KEY, "합판거푸집|4회|m2", "표지석||개"}  # 모르는 꼴 뺌
    assert got[DIG_KEY] == {
        "원래": {"품명": "구조물터파기(인력100%)", "규격": "토사", "단위": "m3"},
        "때": "t1",
        "누가": None,
        "처음파일": None,
        "갈래": "짝",
        "짝": [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": None}],
    }
    assert got["합판거푸집|4회|m2"]["갈래"] == "안 씀" and got["합판거푸집|4회|m2"]["짝"] == []
    assert got["표지석||개"]["짝"] == [{"자재": "MT004258", "입력값": {}, "배": 1, "몫": None}]


def test_층_차례_아래_층이_이김_느슨_찾기(client):
    mine, company, system = ledger.chain(layers.personal_dir(7, 42))
    assert (company, system) == (layers.company_dir(7), store.FOLDER)
    new = {"갈래": "짝", "짝": [{"로직": "GF000103", "입력값": {}, "배": 1, "몫": None}]}
    _put_raw(system, {DIG_KEY: new, "잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}})
    _put_raw(company, {DIG_KEY: {**new, "짝": [{"로직": "GF000102", "배": 1}]}})
    got = ledger.recall(DIG, mine)
    assert (got["층"], got["주인"], got["짝"][0]["로직"], got["규격다름"]) == (
        "company",
        "7",
        "GF000102",
        False,
    )
    _put_raw(mine, {DIG_KEY: {"로직": "GF000101", "환산": 1}})
    assert ledger.recall(DIG, mine)["짝"][0]["로직"] == "GF000101"  # 같은 층 먼저
    rock = {**DIG, "규격": "경암"}
    loose = ledger.recall(rock, mine)
    assert loose["규격다름"] is True and loose["층"] == "personal"  # 품명|단위 느슨
    soil = {"이름": "잔토처리(인력100%)", "규격": "", "단위": "M3"}
    assert ledger.recall(soil, mine)["갈래"] == "우리에 없음"
    assert ledger.recall({"이름": "없는 줄", "단위": "m"}, mine) is None
    assert ledger.recall(DIG, mine, whole=True) is None  # 호표 통째 열쇠는 따로
    books = ledger.books(mine)
    assert ledger.recall(DIG, mine, books)["짝"][0]["로직"] == "GF000101"  # 한 번 읽어 넘김
    rows = ledger.rows(mine, True)
    assert [(r["층"], r["고침"]) for r in rows] == [
        ("personal", True),
        ("company", False),
        ("system", False),
        ("system", False),
    ]  # 위 층 = 읽기만
    assert not any(r["고침"] for r in ledger.rows(mine, False))


def test_재검사(client):
    known = ledger._known()
    ok = {
        "갈래": "짝",
        "짝": [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": "2", "몫": 0.5}],
    }
    got = ledger.check(DIG_KEY, ok, known)
    assert got["짝"] == [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": 0.5}]
    assert got["원래"] == {"품명": "구조물터파기(인력100%)", "규격": "토사", "단위": "m3"}
    assert ledger.check(DIG_KEY, {"갈래": "안 씀"}, known)["짝"] == []
    pair = ok["짝"][0]
    bad = [
        ("a|b", ok),
        (DIG_KEY, {"갈래": "같음", "짝": ok["짝"]}),
        (DIG_KEY, {"갈래": "짝", "짝": []}),
        (DIG_KEY, {"갈래": "안 씀", "짝": ok["짝"]}),
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "로직": "GC000422"}]}),  # 돈 아닌 로직
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "입력값": {"없는칸": 1}}]}),
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "배": 0}]}),
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "배": "nan"}]}),
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "몫": 1.5}]}),
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "자재": "MT004258"}]}),
        (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "금액": 100}]}),  # 금액 칸 받지 않음
        (DIG_KEY, {"갈래": "짝", "짝": [{"자재": "MT000000", "배": 1}]}),
    ]
    for full, raw in bad:
        with pytest.raises(store.StoreError) as error:
            ledger.check(full, raw, known)
        assert error.value.status == 400, raw


def test_쓰기_처음파일_옛_꼴_새로(client):
    before = master_hash()
    mine = layers.personal_dir(7, 42)
    _put_raw(mine, {"합판거푸집|4회|m2": {"빼기": True, "확정": "t"}})
    row = ledger.check(DIG_KEY, {"갈래": "짝", "짝": [{"로직": "GF000101", "배": 1}]})
    assert ledger.write(mine, {DIG_KEY: row}, WHO, "가.xls") == 1
    raw = _raw(mine)
    assert raw["합판거푸집|4회|m2"]["갈래"] == "안 씀"  # 옛 꼴 = 쓸 때 새 꼴
    assert raw[DIG_KEY]["누가"] == WHO and raw[DIG_KEY]["처음파일"] == "가.xls"
    assert raw[DIG_KEY]["때"]
    ledger.write(mine, {DIG_KEY: row}, WHO, "나.xls")
    assert _raw(mine)[DIG_KEY]["처음파일"] == "가.xls"  # 처음파일은 있던 값
    got = ledger.put(mine, {DIG_KEY: None}, WHO)
    assert got["씀"] == 1 and DIG_KEY not in _raw(mine)
    with pytest.raises(store.StoreError):
        ledger.put(mine, {}, WHO)
    assert master_hash() == before