Files
Aislo/resources/tester/test_m02_labor_ref.py
T
eomsangdonandClaude Opus 5.5 badceff991 refactor(855-E L3b ②): 로직 줄 같이 쓰기 끔 — mirror · 스위치 · 빌더 문서 갈래 걷음
- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0)
- Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 ·
  labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움)
- M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 ·
  손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함)
- M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서)
- 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움
- 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 ·
  파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) ·
  848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음
- 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:28:00 +09:00

514 lines
25 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""일위대가 사전조합 서고(PLAN 50-3 · `M02_Labor_Ref`) — 사전조합 · 참조 줄 · 옛 단가승격(134-2).
펼침(재귀 · 순환 · 깊이) · 층 규칙(위 층만) · 쓰는 곳 지우기 409 · 층 사이 따라 복사 ·
프로젝트 굳힘 · 로직 지우기 검사 · TS 짝 settle 거울. 층은 임시 폴더(마스터 · storage).
옛 단가승격(SP) = 새로 못 만듦 · 남은 파일은 읽기 · 셈 · 굳힘만(`_promote` = 옛 파일을 바로 씀) ·
읽을 때 옛 참조 줄을 새 꼴로 바꾸던 것은 858 5-8 에서 걷음(요구 899 — 옛 꼴 호환 없음).
"""
import json
from decimal import Decimal
import pytest
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.helper_855_line import run_line
from resources.tester.test_m02_labor_calc_mirror import _same, _ts
from resources.tester.test_m02_structure import write_sample_table
TEN = "GC000421" # 원/10㎡ — 배 10
STONE = "GF000219" # 원/㎡
PLAIN = "GC000422" # 돈 아닌 로직
SYS = {"층": "system", "주인": None}
COMPANY = {"층": "company", "주인": "7"}
MINE = {"층": "personal", "주인": "7/42"}
@pytest.fixture()
def world(tmp_path, monkeypatch):
from config import config_system
system = tmp_path / "system"
system.mkdir()
write_sample_table(system)
monkeypatch.setattr(store, "FOLDER", system)
monkeypatch.setattr(layers, "SYSTEM_ROOT", system)
(tmp_path / "storage").mkdir()
monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(tmp_path / "storage"))
with store.at(system):
store.create_structure("rv")
return {
"system": system,
"company": layers.company_dir(7),
"personal": layers.personal_dir(7, 42),
}
def _promote(folder, code=TEN, values=None, **extra):
"""옛 단가승격 파일(134-2 앞 꼴) — 층마다 다음 번호 · 배 = 로직 물량 알약 배."""
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
line = {"로직": code, "입력값": values or {}, **extra}
pill = (combo_store.combo_pills({"담은로직": [line]})["물량"] or [{}])[0]
folder = folder / "promote"
folder.mkdir(parents=True, exist_ok=True)
key = f"SP-{len(list(folder.glob('SP-*.json'))) + 1:06d}"
doc = {
"종류": "단가승격",
"키": key,
"이름": pill.get("이름") or code,
"단위": pill.get("단위"),
"배": pill.get("배") or 1,
"담은로직": [line],
"본뜬": None,
}
(folder / f"{key}.json").write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8")
return key
def _combo(folder, lines, name="조합"):
with store.at(folder):
return refs.create("precombo", {"이름": name, "단위": "㎡", "담은로직": lines})["이름"]
def _area(given):
"""면적산출 사본 꼴 — 알약 키마다 칸 하나(723-1 · 안 줄 수량 = 이은 칸 값)."""
cells = {f"A{i}": {"값": v} for i, v in enumerate(given.values(), 1)}
links = [{"칸": f"A{i}", "키": k} for i, k in enumerate(given, 1)]
return {"시트": [{"id": "s", "칸": cells, "연결": links}]}
def _read(folder, kind, key):
return json.loads((folder / kind / f"{key}.json").read_bytes())
def _base(code):
import M01_MasterData.M01_MasterData_Store as m01
return run_line(m01.loaded()[1], code, {})["기준"]
# ── 자료 틀 ────────────────────────────────────────────────────────────
def test_단가승격_서고는_없음_층_종류에서_뺌(world):
assert "promote" not in layers.KINDS and layers.LIBRARY_KINDS == ("precombo", "sangeun")
with store.at(world["system"]), pytest.raises(KeyError):
refs.create("promote", {"담은로직": [{"로직": TEN}]})
def test_사전조합_틀린_줄_400_순환_422(world):
sp = _promote(world["system"])
one = {"참조": {**SYS, "키": sp}}
for lines in (
[{"로직": "GF999999"}], # 모르는 로직
[{"로직": TEN}, {"로직": TEN}], # 같은 로직 두 번(51-11)
[{"로직": TEN, "입력값": [1]}], # 입력값 꼴
[one, one], # 같은 참조 두 번
[{"참조": {**SYS, "키": "SP-000009"}}], # 없는 참조
[{"참조": {**SYS, "키": "SU-000001"}}], # 서고 키 아님
):
with pytest.raises(store.StoreError) as e:
_combo(world["system"], lines)
assert e.value.status == 400
# 740-1 — 사전조합에 사전조합 = 사본 블록(원본 연결 없음) · 되돌려 담아도 순환 없음
a = _combo(world["system"], [one], "가")
b = _combo(world["system"], [{"참조": {**SYS, "키": a}}], "나")
with store.at(world["system"]):
line = store.read("precombo", b)["문서"]["담은로직"][0]
assert line["참조"]["층"] == "사본" and line["본뜬"]["키"] == a
assert line["참조"]["몸"]["담은로직"][0]["참조"] == one["참조"]
have = store.read("precombo", a)
store.write(
"precombo", a, have["판"], {**have["문서"], "담은로직": [{"참조": {**SYS, "키": b}}]}
)
assert store.read("precombo", a)["문서"]["담은로직"][0]["참조"]["층"] == "사본"
def test_층_규칙은_위_층만(world):
_promote(world["system"])
_promote(world["company"])
_promote(world["personal"])
ok = [{"참조": {**s, "키": "SP-000001"}} for s in (SYS, COMPANY, MINE)]
assert _combo(world["personal"], ok) == "SC-000001" # 개인 → 개인 · 회사 · 마스터
for folder, bad in (
(world["company"], MINE), # 회사 → 개인 X
(world["system"], COMPANY), # 마스터 → 회사 X
(world["personal"], {"층": "personal", "주인": "7/43"}), # 남의 개인 X
(world["personal"], {"층": "company", "주인": "8"}), # 남의 회사 X
):
with pytest.raises(store.StoreError) as e:
_combo(folder, [{"참조": {**bad, "키": "SP-000001"}}])
assert e.value.status == 400 and "위 층만" in e.value.detail
def test_일위대가_참조_줄_정리_같은_참조_두_번_400(world):
sp = _promote(world["system"])
line = {"참조": {**SYS, "키": sp}, "별칭": " 승격 ", "수량": {"손": 3}}
with store.at(world["system"]):
got = labor.clean({"열": "rv", "담은로직": [line]})["담은로직"]
assert got == [{"참조": {**SYS, "키": sp}, "별칭": "승격", "메모": None, "수량": {"손": 3}}]
with pytest.raises(store.StoreError) as e:
labor.clean({"열": "rv", "담은로직": [line, line]})
assert e.value.status == 400
# ── 펼침(계산) ─────────────────────────────────────────────────────────
def test_calc_는_참조를_펼침_승격은_기준_나누기_배_사전조합은_수량_곱(world):
sp = _promote(world["system"])
sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}, "수량": {"손": 2}}], "둘")
ref = {**SYS, "키": sc}
with store.at(world["system"]):
doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 5}}]})
bare = labor.calc(doc, {})["줄"][0] # 742-1 — 안 줄 저장 수량(손 2)
got = labor.calc(doc, {f"{refs.ref_id(ref)}#0": 2}) # 안 줄 알약 = 구조물 조합 칸 값
fed = labor.calc(doc, {f"{refs.ref_id(ref)}#0": 4})["줄"][0] # 알약이 저장보다 앞섬
want = Decimal(str(_base(TEN)["계"])) / 10 * 2
near = 3 # 751-3 — 안 줄 0.1 원 · 비목 합 1 원 버림
assert bare["기준"]["계"] == pytest.approx(float(want), abs=near) and bare["안"][0]["수량"] == 2
assert (
fed["기준"]["계"] == pytest.approx(float(want * 2), abs=near) and fed["안"][0]["수량"] == 4
)
one = got["줄"][0]
assert one["기준"]["계"] == pytest.approx(float(want), abs=near)
assert (one["분모"], one["배"], one["알약"]) == (
"㎡",
1,
refs.ref_id(ref),
) # 단위 = 그 사전조합 것
assert one["반영"]["계"] == pytest.approx(float(want * 5), abs=20) # 751-3 끝수 × 5
assert one["안"][0]["수량"] == 2 and one["안"][0]["참조"]["키"] == sp
pills = labor.pills(doc)
assert pills[0] == {"키": refs.ref_id(ref), "이름": "둘", "단위": "㎡", "로직": [], "참조": ref}
assert [p["키"] for p in pills[1:]] == [f"{refs.ref_id(ref)}#0"] # 안 줄 알약(723-1)
assert pills[1]["이름"].startswith("둘 · ")
def test_승격_줄_상세는_원_로직_키_표_사전조합은_안_줄만(world):
sp = _promote(world["system"])
sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}}], "하나")
with store.at(world["system"]):
doc = labor.clean({"열": "rv", "담은로직": [{"참조": {**SYS, "키": k}} for k in (sp, sc)]})
promote, combo = labor.calc(doc, {})["줄"]
assert promote["원로직"] == TEN and promote["줄"]
assert sum(x["금액"] for x in promote["줄"]) == pytest.approx(
promote["기준"]["계"], abs=0.3
) # 1 단위(51-2) · 비목 합 1 원 버림 ÷ 배(751-3)
assert "줄" not in combo and [x["참조"]["키"] for x in combo["안"]] == [sp]
def test_펼침은_순환_깊이_없는_참조를_까닭으로_멈춤(world):
folder = world["system"] / "precombo"
for key, child in (("SC-000001", "SC-000002"), ("SC-000002", "SC-000001")):
body = {"이름": key, "담은로직": [{"참조": {**SYS, "키": child}}]}
(folder / f"{key}.json").write_text(json.dumps(body), encoding="utf-8")
import M01_MasterData.M01_MasterData_Store as m01
expand = refs.Expand(m01.loaded()[1])
got = expand({**SYS, "키": "SC-000001"})
assert got["기준"] is None and "순환" in got["까닭"]
assert "없는 참조" in expand({**SYS, "키": "SC-000009"})["까닭"]
deep = refs.Expand(
m01.loaded()[1], lambda r: {"담은로직": [{"참조": {**SYS, "키": "SC-000001"}}]}
)
assert deep.__call__({**SYS, "키": "SC-000001"}, ())["기준"] is None
def test_돈_아닌_승격은_까닭(world):
sp = _promote(world["system"], PLAIN)
import M01_MasterData.M01_MasterData_Store as m01
got = refs.Expand(m01.loaded()[1])({**SYS, "키": sp})
assert got["기준"] is None and got["까닭"]
def test_참조_줄_settle_파이썬과_TS_가_같은_답(world):
sp = _promote(world["system"])
ref = {**SYS, "키": sp}
with store.at(world["system"]):
doc = labor.clean(
{"열": "rv", "담은로직": [{"로직": STONE, "수량": None}, {"참조": ref, "수량": None}]}
)
answer = labor.calc(doc, {})
values = {refs.ref_id(ref): 4}
py = labor.settle(answer, doc, values)
assert py["줄"][1]["수량출처"] == "칸"
_same(py, _ts(answer, doc, values))
# ── 지우기 · 복사 · 굳힘 · 로직 지우기 ─────────────────────────────────
def test_쓰는_곳이_있으면_지우기_409_없으면_지움(world):
sc = _combo(world["system"], [{"로직": TEN}])
with store.at(world["personal"]):
line = {"참조": {**SYS, "키": sc}}
store.write("labor", "x1", "", {"열": "x1", "담은로직": [line], "자재": []})
with store.at(world["system"]), pytest.raises(store.StoreError) as e:
store.delete("precombo", sc)
assert e.value.status == 409 and "개인 7/42" in e.value.detail
(world["personal"] / "labor" / "x1.json").unlink()
with store.at(world["system"]):
store.delete("precombo", sc)
assert not (world["system"] / "precombo" / f"{sc}.json").exists()
def test_쓰는_곳_기억은_파일을_고치면_다시_읽음_818_1(world):
sc = _combo(world["system"], [{"로직": TEN}])
ref = {**SYS, "키": sc}
with store.at(world["personal"]):
store.write("labor", "x1", "", {"열": "x1", "담은로직": [{"참조": ref}], "자재": []})
assert len(library_uses.users(ref)) == 1 and library_uses.users(ref) == library_uses.users(
ref, library_uses.files()
)
ver = store.read("labor", "x1")["판"]
store.write("labor", "x1", ver, {"열": "x1", "담은로직": [], "자재": []})
assert library_uses.users(ref) == []
def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):
inner = _combo(world["personal"], [{"로직": TEN}], "안")
sys_sp = _promote(world["system"])
sc = _combo(
world["personal"],
[{"참조": {**MINE, "키": inner}}, {"참조": {**SYS, "키": sys_sp}, "수량": {"손": 2}}],
)
with store.at(world["personal"]):
doc = store.read("precombo", sc)["문서"]
with store.at(world["company"]):
made = refs.create(
"precombo", refs.carry({**doc, "본뜬": {**MINE, "키": sc}}, ("personal", "7/42"))
)
got = _read(world["company"], "precombo", made["이름"])
assert got["본뜬"] == {**MINE, "키": sc}
# 740-1 — 개인 사전조합은 넣을 때 사본 블록(본뜬) → 회사로 따로 복사 안 함 ·
# 마스터 옛 승격 그대로
block = got["담은로직"][0]
assert block["참조"]["층"] == "사본" and block["본뜬"]["키"] == inner
assert got["담은로직"][1]["참조"] == {**SYS, "키": sys_sp}
assert made["이름"] == "SC-000001" # 딸림 복사 없음
# 못 읽는 옛 개인 승격은 따라 복사 안 함(134-2 · 승격 서고 없음)
mine_sp = _promote(world["personal"])
with store.at(world["company"]), pytest.raises(store.StoreError) as e:
refs.carry({"담은로직": [{"참조": {**MINE, "키": mine_sp}}]}, ("personal", "7/42"))
assert e.value.status == 400
def test_복사_새_키_규격_열_수량도_따라감(world):
"""통합 점검 — 회사에 올리기 승인 · 회사로 복사: 개인 참조가 회사 새 키로 바뀌면 규격 열 수량 열쇠도."""
inner = _combo(world["personal"], [{"로직": TEN}], "안")
old = f"참조|personal|7/42|{inner}"
spec = {
"이름": "H",
"열": ["1.5", "2.0"],
"기본": "1.5",
"수량": {old: {"1.5": 1, "2.0": 1.3}, "고정|돌|가|㎡": {"1.5": 2, "2.0": 2.6}},
}
doc = {"담은로직": [{"참조": {**MINE, "키": inner}}], "규격": spec}
with store.at(world["company"]):
got = refs.carry(doc, ("personal", "7/42"))
new = f"참조|company|7|{got['담은로직'][0]['참조']['키']}"
assert got["규격"]["수량"] == {
new: {"1.5": 1, "2.0": 1.3},
"고정|돌|가|㎡": {"1.5": 2, "2.0": 2.6},
}
assert doc["규격"]["수량"][old] == {"1.5": 1, "2.0": 1.3} # 원본 그대로
def test_길_새로_복사_권한(world):
from fastapi import FastAPI
from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_Labor_Router as labor_router
app = FastAPI()
app.include_router(labor_router.router)
app.dependency_overrides[verify_session] = lambda: {
"user_id": 42,
"company_id": 7,
"role": "USER",
"is_master": False,
}
client = TestClient(app)
url = "/api/m02/layers/{}/library/{}"
body = {"문서": {"이름": "가", "단위": "㎡", "담은로직": [{"로직": TEN}]}}
got = client.post(url.format("personal", "precombo"), json=body).json()
assert got["이름"] == "SC-000001"
assert client.post(url.format("system", "precombo"), json=body).status_code == 403
copy = {"본뜬": {**MINE, "키": "SC-000001"}}
assert client.post(url.format("personal", "precombo"), json=copy).json()["이름"] == "SC-000002"
other = {"본뜬": {"층": "personal", "주인": "7/99", "키": "SC-000001"}}
assert client.post(url.format("personal", "precombo"), json=other).status_code == 403
assert client.post(url.format("personal", "promote"), json=body).status_code == 422 # 134-2
def test_프로젝트는_참조사본으로_굳힘_원본을_지워도_같은_값(world):
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Item_Source as source
sp = _promote(world["system"])
sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}, "수량": {"손": 2}}])
ref = {**SYS, "키": sc}
given = {f"{refs.ref_id(ref)}#0": 2} # 723-1 — 안 줄 수량 = 이은 칸 값
with store.at(world["system"]):
doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 1}}]})
live = labor.calc(doc, given)["줄"][0]["기준"]["계"]
rows = source.labor_doc_rows(doc)
assert set(rows["참조사본"]) == {refs.ref_id(ref), refs.ref_id({**SYS, "키": sp})}
assert refs.frozen_logics(rows["참조사본"]) == [TEN]
bundle = prices.to_json(prices.collect([TEN]))
for key in (sc, sp): # 원본이 사라져도 프로젝트는 사본만 봄
kind = refs.kind_of(key)
(world["system"] / kind / f"{key}.json").unlink()
got = prices.calc(rows, bundle, {}, {}, _area(given))
line = got["줄"][0]
assert not line["까닭"] and line["참조"] == ref # 층 셈 꼴(142-1)
assert line["기준"]["계"] == pytest.approx(live, rel=1e-9)
assert line["수량"] == 1 and line["반영"]["계"] == pytest.approx(live, rel=1e-9)
def test_로직_지우기_검사는_승격_줄도_보고_참조_줄은_건너뜀(world):
from M01_MasterData import M01_MasterData_Store_Cache as cache
sp = _promote(world["system"], STONE)
with store.at(world["system"]):
have = store.read("labor", "rv")
line = {"참조": {**SYS, "키": sp}}
store.write("labor", "rv", have["판"], {**have["문서"], "담은로직": [line]})
class Gone: # STONE 을 지운 기초(있는 기초 키 묶음)
def __contains__(self, code):
return code != STONE
assert cache.labor_errors(Gone()) == [] # 옛 승격 서고는 안 봄(134-2) · 참조 줄 건너뜀
with store.at(world["system"]):
have = store.read("labor", "rv")
line = {"로직": STONE, "승격": True}
store.write("labor", "rv", have["판"], {**have["문서"], "담은로직": [line]})
number = store.read("labor", "rv")["문서"]["일위대가번"]
got = cache.labor_errors(Gone())
assert got == [f"일위대가 마스터 「{number}」 이 로직 「{STONE}」 을 씀 — 거기서 먼저 뺌"]
def test_새_프로젝트_씨앗은_서고를_안_가져감(world, tmp_path):
_promote(world["system"])
got = layers.seed_project(tmp_path / "p1")
assert not any(k.startswith(layers.LIBRARY_KINDS) for k in got["작업본"])
def test_층_목록_서고_줄은_이름_단위_기준금액을_실음(world):
sp = _promote(world["system"])
sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}, "수량": {"손": 3}}], "셋")
rows = [{"종류": "precombo", "이름": sc}, {"종류": "labor", "이름": "rv"}]
refs.summaries(world["system"], rows)
# 742-1 — 목록 기준금액 = 안 줄 저장 수량(손 3)으로
want = Decimal(str(_base(TEN)["계"])) / 10 * 3
assert rows[0]["제목"] == "셋" and rows[0]["기준금액"] == pytest.approx(
float(want), abs=3
) # 751-3
assert "기준금액" not in rows[1]
def test_사전조합_로직_줄_섞임_합은_손셈_지우기_409_굳힘(world):
from M01_MasterData import M01_MasterData_Store_Cache as cache
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Item_Source as source
sp = _promote(world["system"])
lines = [
{"참조": {**SYS, "키": sp}, "수량": {"손": 2}},
{"로직": STONE, "입력값": {"없는칸": 1}, "수량": {"손": 3}, "메모": "돌"},
{"로직": TEN},
]
sc = _combo(world["system"], lines, "섞음")
saved = _read(world["system"], "precombo", sc)["담은로직"]
assert saved[1:] == [ # 742-1 — 안 줄 수량 저장(빈 수량 = null)
{"로직": STONE, "입력값": {}, "수량": {"손": 3}, "메모": "돌"},
{"로직": TEN, "입력값": {}, "수량": None, "메모": None},
]
ten, stone = (Decimal(str(_base(c)["계"])) for c in (TEN, STONE))
want = ten / 10 * 2 + stone * 3 + ten / 10 * 1 # 이은 수량 — 승격 · TEN 은 원/10㎡(배 10)
ref = {**SYS, "키": sc}
given = {f"{refs.ref_id(ref)}#{i}": q for i, q in enumerate((2, 3, 1))}
with store.at(world["system"]):
doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 5}}]})
one = labor.calc(doc, given)["줄"][0]
assert one["기준"]["계"] == pytest.approx(float(want), abs=4) # 751-3 안 줄 셋 · 비목 합 버림
assert one["반영"]["계"] == pytest.approx(float(want * 5), abs=20) # 751-3 끝수 × 5
assert [x.get("로직") or x["참조"]["키"] for x in one["안"]] == [sp, STONE, TEN]
class Gone: # STONE 을 지운 기초(있는 기초 키 묶음)
def __contains__(self, code):
return code != STONE
got = cache.labor_errors(Gone())
assert f"사전조합 마스터 「{sc}」 이 로직 「{STONE}」 을 씀 — 거기서 먼저 뺌" in got
rows = source.labor_doc_rows(doc)
assert sorted(refs.frozen_logics(rows["참조사본"])) == sorted([TEN, STONE, TEN])
bundle = prices.to_json(prices.collect([TEN, STONE]))
for key in (sc, sp): # 원본이 사라져도 굳힌 사본으로 같은 값
(world["system"] / refs.kind_of(key) / f"{key}.json").unlink()
got = prices.calc(rows, bundle, {}, {}, _area(given))["줄"][0]
assert got["기준"]["계"] == pytest.approx(float(want), abs=4) # 751-3 안 줄 셋 · 비목 합 버림
def test_사전조합이_자기_자신을_담으면_422_수량_없음(world):
sp = _promote(world["system"])
a = _combo(world["system"], [{"참조": {**SYS, "키": sp}}], "가")
with store.at(world["system"]):
have = store.read("precombo", a)
assert have["문서"]["담은로직"][0]["수량"] is None # 723-1 — 기본 1 걷음
with pytest.raises(store.StoreError) as e:
store.write(
"precombo",
a,
have["판"],
{
**have["문서"],
"담은로직": [*have["문서"]["담은로직"], {"참조": {**SYS, "키": a}}],
},
)
assert e.value.status == 422 and "자기 자신" in e.value.detail
def test_서고_구분_상세구분_사전조합은_고른_값(world):
sp = _promote(world["system"])
sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}}])
assert (_read(world["system"], "precombo", sc)["구분"], "") == ("", "")
with store.at(world["system"]):
have = store.read("precombo", sc)
store.write("precombo", sc, have["판"], {**have["문서"], "구분": " 가 ", "상세구분": "나"})
got = _read(world["system"], "precombo", sc)
assert (got["구분"], got["상세구분"]) == ("가", "나")
rows = [{"종류": "precombo", "이름": sc}]
refs.summaries(world["system"], rows)
assert (rows[0]["구분"], rows[0]["상세구분"], rows[0]["연결"]) == ("가", "나", None)
def test_사전조합_굳힘은_안_로직_알약도_사본_값_142_2(world, monkeypatch):
"""프로젝트 참조사본 사전조합 = 가져온 때 알약(배 10) — 그 뒤 M01 이 바뀌어도 사본 셈 그대로 ·
층 문서(알약 없음)는 지금 M01 을 읽음."""
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Item_Source as source
sc = _combo(world["system"], [{"로직": TEN}], "열배")
ref = {**SYS, "키": sc}
with store.at(world["system"]):
doc = labor.clean({"열": "rv", "담은로직": [{"참조": ref, "수량": {"손": 1}}]})
rows = source.labor_doc_rows(doc)
given = {f"{refs.ref_id(ref)}#0": 1}
kept = rows["참조사본"][refs.ref_id(ref)]["알약"]
assert [(p["로직"], p.get("배")) for p in kept] == [([TEN], 10)]
assert "알약" not in _read(world["system"], "precombo", sc) # 층 문서는 그대로
bundle = prices.to_json(prices.collect([TEN]))
before = prices.calc(rows, bundle, {}, {}, _area(given))["줄"][0]["기준"]["계"]
changed = {"물량": [{"키": "x|㎡", "이름": "x", "단위": "㎡", "로직": [TEN]}]} # 배 1 로 바뀜
monkeypatch.setattr(combo_store, "combo_pills", lambda row: changed)
again = prices.calc(rows, bundle, {}, {}, _area(given))["줄"][0]["기준"]["계"]
assert again == pytest.approx(before)
with store.at(world["system"]):
live = labor.calc(doc, given)["줄"][0]["기준"]["계"]
assert live == pytest.approx(before * 10, abs=30) # 층 셈은 지금 M01(배 1) · 751-3 끝수 × 10