- 화면: 열 때 알림 창(표 · [위 값으로] · [확인] · [나중에]) → 토스트 「M01 기초가 바뀌어 반영됨」(+ 「내가 고친 칸 n 은 내 값 그대로」 · 「다시 못 얹은 내 고침 n」) · 확인 단추 없음
- 되풀이 막기: 서버 읽기 답 `사본.따라옴` = 저장본 대 지금 사본의 M01 몫 지문(값 판 · 부른 문서 · 바탕 판 · 문서 계산 내용 · 같으면 null) ·
화면 localStorage(SK 길마다 {따라옴 지문, 알림 글}) — 새 지문 · 새 알림일 때만 · [저장] 하면 지문 없음
- 머리 띠 「바탕 단가산출 기초가 저장 뒤 바뀜」 · 배지 「M01 개정 — 확인」 · 「지워짐 n」 배지 걷음 · 글 키 걷음
- 서버: [확인] 저장 할일 `갱신확인`(`renew.CONFIRM` · form/_covers/_soft confirm 갈래) · 수식 길 `할일` 칸 걷음 ·
읽기 답 바뀜 표지(M01새판 · 지운키 · 단가새값 · 문서새판 · 자동 = 열 때마다 dc.state 셈) 걷음
- 자동 반영 · 내 고친 칸 지킴(파란 테두리 · 풍선 「원래 값」) 그대로
- 시험: 836_2 ㉧ 토스트 지문(만든 뒤 없음 · 바뀜 = 같은 지문 · 저장 뒤 없음 · 또 바뀜 = 다른 지문) · 848_10 따로 문서 옵션 따라옴 = 지문 ·
확인 저장 단언은 [저장] 꼴로 · test_confirm_clears 지움 · 읽기 답 표지 단언 걷음 · 856_0 띠 = 빠진 줄만
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
211 lines
9.7 KiB
Python
211 lines
9.7 KiB
Python
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||
"""802-4a M02 단가산출 · 일위대가 · B09 사본 = 수식 문서 — 임시 storage · M01 은 메모리 덮개.
|
||
|
||
① 찍기 = M01 문서 사본(금액 = M01 문서 셈) ② 고침 = 사본 문서(M01 안 바뀜 · 옛 칸 고침 409)
|
||
(③ [단가 갱신] · ④ [재생성] = 859-2 걷음)
|
||
⑤ 단가산출 연결 = 부름 사본 · 끊기 = 사본 안에 굳힘 ⑥ SC · 일위대가 = 문서 셈(옛 금액 같음 ·
|
||
줄 규칙 켜쌓기율 · 고른 자재 · 별도계상) ⑦ B09 사본 `수식.json` ⑧ 권한 ⑨ 지움 견딤 · 빈 SK 「—」.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import copy
|
||
|
||
import pytest
|
||
from fastapi import HTTPException
|
||
|
||
from M02_MasterTemplete import M02_Doc_B09 as doc_b09
|
||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||
from M02_MasterTemplete import M02_Doc_Router as router
|
||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||
from M02_MasterTemplete import M02_Item_Snapshot as snap
|
||
from M02_MasterTemplete import M02_Item_Source as source
|
||
from M02_MasterTemplete import M02_Labor_Copy as lc
|
||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||
from resources.tester.test_795_1_sk_copy import (
|
||
_calc,
|
||
_changed,
|
||
_doc,
|
||
_fake,
|
||
_live,
|
||
_m01_doc,
|
||
_save,
|
||
_sk,
|
||
)
|
||
from resources.tester.test_795_2_sc_copy import PCT, _labor, _sc
|
||
from resources.tester.test_795_2_sc_copy import _calc as _sc_calc
|
||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||
|
||
|
||
@pytest.fixture(autouse=True)
|
||
def _manual(monkeypatch):
|
||
"""836-2 — 이 시험 = 손 갱신 길(프로젝트 층 꼴 · 자동 따라옴 끔) · 자동 = test_836_2."""
|
||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||
|
||
monkeypatch.setattr(renew, "on", lambda: False)
|
||
|
||
|
||
FORM = "GC000211" # 합판거푸집(옵션 많음)
|
||
|
||
|
||
def _sum(folder, key):
|
||
return _calc(folder, _doc(folder, key))["기준"]["계"]
|
||
|
||
|
||
def _at(folder, fn, *args):
|
||
with store.at(folder):
|
||
return fn(*args)
|
||
|
||
|
||
def _twice(doc, at=0):
|
||
"""금액 줄 하나 수량 × 2 — 사용자 고침 흉내."""
|
||
doc = copy.deepcopy(doc)
|
||
line = doc["금액"][at]
|
||
line["수량"] = f"({line.get('수량') or 1}) × 2"
|
||
return doc
|
||
|
||
|
||
def test_stamp_is_m01_doc_copy(world):
|
||
"""① 만들 때 M01 문서를 찍음 — 키 = SK · 옵션 값 · 금액 = M01 문서 셈 = 옛 금액."""
|
||
me = world["personal"]
|
||
key = _sk(me, 바탕={"로직": FORM}, 입력값={"유형": "복잡", "사용횟수": "3회"})
|
||
got = _doc(me, key)[dc.KEY]
|
||
root, m01 = got["문서"], dc.folder()[FORM]
|
||
assert root["키"] == key and [v["기호"] for v in root["변수"]] == [
|
||
v["기호"] for v in m01["변수"]
|
||
]
|
||
assert next(v for v in root["변수"] if v["열쇠"] == "유형")["연결"]["값"] == "복잡"
|
||
assert not got.get("따로") and got["로직"] and got["단가"]
|
||
m01_calc = dc.mc.calc(root, dc.ml.Links(_live(), dc.folder()))
|
||
assert _sum(me, key) == m01_calc["계"]
|
||
read = _at(me, path.read, key)
|
||
assert read["셈"]["계"] == m01_calc["계"] and read["사본"]["따로"] is False
|
||
|
||
|
||
def test_edit_goes_to_copy_doc(world):
|
||
"""② 고침 = 그 사본 문서(따로) · M01 문서 그대로 · 옛 칸 고침 저장 409 · 다시 열어 같음."""
|
||
me = world["personal"]
|
||
key = _sk(me, 바탕={"로직": PCT})
|
||
was, m01_before = _sum(me, key), dc.fp(dc.folder()[PCT])
|
||
read = _at(me, path.read, key)
|
||
pre = _at(me, path.preview, key, {"문서": _twice(read["문서"])})
|
||
assert pre["전"]["계"] == was and pre["후"]["계"] > was
|
||
saved = _at(me, path.save, key, {"문서": _twice(read["문서"]), "판": read["판"]})
|
||
assert saved["사본"]["따로"] is True and saved["셈"]["계"] == pre["후"]["계"]
|
||
assert _sum(me, key) == pre["후"]["계"] # SK 금액(일위대가가 쓰는 값) = 고친 문서
|
||
assert dc.fp(dc.folder()[PCT]) == m01_before
|
||
assert _at(me, path.read, key)["문서"] == saved["문서"]
|
||
doc = _doc(me, key)
|
||
with pytest.raises(store.StoreError) as e:
|
||
_save(me, key, {**doc, "입력값": {"x": 1}, "덮개": {"labor:LB000036#0": {"qty": 3}}})
|
||
assert e.value.status == 409
|
||
_save(me, key, {**doc, "이름": "sub2임시 이름만"}) # 머리 칸 = 그대로 받음
|
||
assert _sum(me, key) == pre["후"]["계"]
|
||
with pytest.raises(store.StoreError) as e: # 판 다름
|
||
_at(me, path.save, key, {"문서": read["문서"], "판": read["판"]})
|
||
assert e.value.status == 409
|
||
|
||
|
||
CALLER, CALLED = "GC000006", "GC000267" # 가설울타리 강관 지주 → 굴착기(무한궤도) 시간당
|
||
|
||
|
||
def test_link_copy_unlink_freezes(world, monkeypatch):
|
||
"""⑤ 단가산출 연결 = 부름 사본 · 끊기 = 사본 안 고침(859-2 [재생성] 걷음)."""
|
||
me = world["personal"]
|
||
key = _sk(
|
||
me, 바탕={"로직": CALLER}, 단위="m"
|
||
) # 기초 문서가 부르는 단가산출(855 2-C1 — 옛 더한줄 대신)
|
||
was = _sum(me, key)
|
||
read = _at(me, path.read, key)
|
||
assert CALLED in read["부름"]
|
||
cut = {CALLED: _twice(read["부름"][CALLED])}
|
||
pre = _at(me, path.preview, key, {"끊음": cut})
|
||
assert pre["후"]["계"] > was
|
||
saved = _at(me, path.save, key, {"끊음": cut, "판": read["판"]})
|
||
assert (
|
||
saved["끊음"][CALLED] == {**cut[CALLED], "키": CALLED} and _sum(me, key) == pre["후"]["계"]
|
||
)
|
||
_fake(monkeypatch, [_changed(_m01_doc(CALLED))]) # 원본 바뀜
|
||
assert _sum(me, key) == pre["후"]["계"] # 끊은 것 · 연결 모두 그대로(누르기 전)
|
||
with pytest.raises(store.StoreError) as e: # 부르지 않는 키 끊기
|
||
_at(me, path.preview, key, {"끊음": {"GC999999": read["부름"][CALLED]}})
|
||
assert e.value.status == 400
|
||
|
||
|
||
def test_sc_and_labor_use_doc(world, monkeypatch):
|
||
"""⑥ SC · 일위대가 로직 줄 = 문서 셈(부름 사본) · 옛 엔진 금액과 같음 · M01 바뀌어도 그대로."""
|
||
me = world["personal"]
|
||
sc = _sc(me, [{"로직": PCT, "수량": {"손": 1}}])
|
||
_labor(me, [{"로직": FORM, "수량": {"손": 2}, "입력값": {"유형": "보통"}}])
|
||
stored = _at(me, store.read, "precombo", sc)["문서"]
|
||
assert dc.has(stored) and PCT in stored[dc.KEY]["부름"]
|
||
runs = []
|
||
real = lc._traced # 로직 줄 문서 셈(855 2-C5 — 셈 기록 같이)
|
||
monkeypatch.setattr(lc, "_traced", lambda *a, **k: runs.append(1) or real(*a, **k))
|
||
new = (_sc_calc(me, sc)["기준합"], _sc_calc(me, "sub2임시")["반영합"])
|
||
assert runs
|
||
_fake(monkeypatch, [_changed(_m01_doc(PCT))])
|
||
assert _sc_calc(me, sc)["기준합"] == new[0]
|
||
|
||
|
||
def test_b09_copy_has_doc_file(world, monkeypatch):
|
||
"""⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판에 듦(로직 몫 · 855-F B9-6) ·
|
||
M01 바뀌어도 그대로."""
|
||
me = world["personal"]
|
||
doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}])
|
||
rows = source.labor_doc_rows(doc)
|
||
files = doc_b09.attach({"일위대가.json": rows, "단가.json": source.price_bundle(rows, me)})
|
||
made = files[doc_b09.FILE]
|
||
assert made["그룹"] == "수식문서" and PCT in made["문서"]
|
||
assert doc_b09.FILE in snap.source_files(files)
|
||
assert doc_b09.attach(files) is files # 이미 있음 = 그대로
|
||
_fake(monkeypatch, [_changed(_m01_doc(PCT))])
|
||
again = doc_b09.build(source.price_bundle(rows, me), rows)
|
||
assert again["문서"][PCT] == made["문서"][PCT] # 일위대가 수식 사본 = 만든 때
|
||
|
||
|
||
def _session(role="USER"):
|
||
return {"role": role, "company_id": 7, "user_id": 42}
|
||
|
||
|
||
def test_permission_layer(world):
|
||
"""⑧ 읽기 = 층 읽기 · 미리 셈 · 저장 = 층 쓰기(마스터 = 시스템 관리자 · 회사 = 회사 관리자)."""
|
||
me = world["personal"]
|
||
key = _sk(me, 바탕={"로직": PCT})
|
||
body = router.DocBody(문서=_at(me, path.read, key)["문서"])
|
||
for layer in ("system", "company"):
|
||
for fn in (router.preview_doc, router.save_doc):
|
||
with pytest.raises(HTTPException) as e:
|
||
fn(layer, key, body, None, _session())
|
||
assert e.value.status_code == 403
|
||
assert router.read_doc("personal", key, None, _session())["셈"]["셈됨"]
|
||
got = router.preview_doc("personal", key, body, None, _session())
|
||
assert got["후"] == got["전"]
|
||
|
||
|
||
def test_delete_tolerant_and_blank(world):
|
||
"""⑨ 무엇을 지워도 오류 없음 — 변수 지움 = 정의 필요 · 금액 「—」 · 저장됨 · 빈 SK = 「—」."""
|
||
me = world["personal"]
|
||
key = _sk(me, 바탕={"로직": PCT})
|
||
read = _at(me, path.read, key)
|
||
gone = copy.deepcopy(read["문서"])
|
||
gone["변수"] = [v for v in gone["변수"] if v["열쇠"] != "w_지붕잇기공"]
|
||
pre = _at(me, path.preview, key, {"문서": gone})
|
||
assert pre["셈"]["셈됨"] is False and pre["후"] is None
|
||
assert any(m["갈래"] == "정의 필요" for m in pre["셈"]["표지"])
|
||
_at(me, path.save, key, {"문서": gone, "판": read["판"]})
|
||
got = _calc(me, _doc(me, key))
|
||
assert got["기준"] is None and got["수식셈"]["셈됨"] is False
|
||
lost = copy.deepcopy(read["문서"])
|
||
lost["변수"].append({"열쇠": "b", "기호": "b", "연결": {"갈래": "단가산출", "키": "GC999999"}})
|
||
lost["금액"].append({"이름": "없는 기초", "비목": "묶음", "단가": "b"})
|
||
pre = _at(me, path.preview, key, {"문서": lost})
|
||
assert any(m["갈래"] == "연결 끊김" for m in pre["셈"]["표지"])
|
||
for bad in ({"문서": "글"}, {"문서": {"금액": "x"}}, {"끊음": []}): # 859-2 할일 칸 걷음
|
||
with pytest.raises(store.StoreError) as e:
|
||
_at(me, path.preview, key, bad)
|
||
assert e.value.status == 400
|
||
empty = _sk(me)
|
||
got = _calc(me, _doc(me, empty))
|
||
assert got["기준"] is None and "빈 문서" in got["수식셈"]["까닭"]
|