- 화면: 열 때 알림 창(표 · [위 값으로] · [확인] · [나중에]) → 토스트 「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>
236 lines
10 KiB
Python
236 lines
10 KiB
Python
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
|
"""822-1 사본 빈틈 막기(요구 797-1) — 길마다: 만들기 → [저장] → M01 값(임시 · 메모리 덮개)을
|
|
기계 가격 · 노임 · 유가 · 자재 값으로 바꿈 → 금액 그대로(859-2 [단가 갱신] · 바뀜 표지 걷음).
|
|
|
|
길 = 수식 길 줄 쌓기(품셈 기계 · 바꿔 끼운 기계 · 자원 줄 · 단가산출 참조) ·
|
|
옛 로직 길(더한줄 로직 · 재료 · 인력) · 가져온 식(단가기준 우리) · 층 복사 ·
|
|
빈틈 SK(지금 값으로 셈 · 저장하면 굳음).
|
|
M01 바꿈 = `skc.Copy` 아닌 진짜 색인 사본(`dc.base` 가 못 벗김) · 정본 파일 안 고침.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import json
|
|
|
|
import pytest
|
|
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
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)
|
|
|
|
|
|
DIG, DIG_NO, DIG_LOGIC = "EQ000022", "0201-0100", "GC000267" # 굴착기(무한궤도) 1.0㎥
|
|
DIG2_NO = "0201-0070" # 바꿔 끼울 굴착기
|
|
MAN = "LB000002" # 보통인부
|
|
PCT = "GC001109" # 금속기와 해체(인력 둘 + 노무비 3 %)
|
|
|
|
|
|
def _live():
|
|
return m01.loaded()[1]
|
|
|
|
|
|
def _move(monkeypatch, *keys: str) -> None:
|
|
"""M01 값 두 배 — 키마다 값 칸(기계 = 가격 · 자재 = 물가 칸) · 진짜 색인 사본(Copy 아님) ·
|
|
수식 문서 폴더 그대로."""
|
|
files, live = m01.loaded()
|
|
fake = copy.copy(live)
|
|
fake.index, fake.numbers = dict(live.index), dict(live.numbers)
|
|
for key in keys:
|
|
tid = key[:2]
|
|
row = copy.deepcopy(live.index[tid][key])
|
|
if tid == "EQ":
|
|
row["값"]["가격"] *= 2
|
|
elif tid == "MT":
|
|
for k in ("물가자료", "유통물가", "물가정보", "거래가격"):
|
|
row[k] = row[k] * 2 if row.get(k) else row.get(k)
|
|
else:
|
|
row["값"] *= 2
|
|
fake.index[tid] = {**fake.index[tid], key: row}
|
|
if row.get("원문번호"):
|
|
fake.numbers[tid] = {**fake.numbers[tid], str(row["원문번호"]): row}
|
|
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
|
|
|
|
|
|
def _at(folder, fn, *args):
|
|
with store.at(folder):
|
|
return fn(*args)
|
|
|
|
|
|
def _sk(folder, **body) -> str:
|
|
body = {"이름": "sub1임시 빈틈", "단위": "시간", "더한줄": [], **body}
|
|
return _at(folder, lambda: refs.create("sangeun", body)["이름"])
|
|
|
|
|
|
def _var(sym: str, link: dict, name: str = "") -> dict:
|
|
return {"기호": "P", "아래": sym, "위": "", "이름": name or sym, "단위": "", "연결": link}
|
|
|
|
|
|
def _line(sym: str, part: str = "경비") -> dict:
|
|
return {"이름": sym, "단위": "hr", "비목": part, "수량": "1", "단가": f"P_{sym}"}
|
|
|
|
|
|
def _stack(folder, key, rows: list[tuple[str, dict, str]]) -> None:
|
|
"""줄 쌓기 — 지금 문서에 (기호, 연결, 비목) 줄을 더해 수식 길로 저장."""
|
|
got = _at(folder, path.read, key)
|
|
doc = copy.deepcopy(got["문서"])
|
|
doc.setdefault("변수", []).extend(_var(s, link) for s, link, _ in rows)
|
|
doc.setdefault("금액", []).extend(_line(s, part) for s, _, part in rows)
|
|
_at(folder, path.save, key, {"문서": doc, "판": got["판"]})
|
|
|
|
|
|
def _sum(folder, key):
|
|
return _at(folder, path.read, key)["셈"]["계"]
|
|
|
|
|
|
MACHINE = {"갈래": "단가산출", "키": DIG_LOGIC, "입력": {"기계": f"'{DIG_NO}'"}}
|
|
|
|
|
|
def _fuel_and_crew(no: str = DIG_NO) -> tuple[str, str]:
|
|
"""기계 시간당 식이 읽는 유가(MO) · 조종원 노임(LB) 키."""
|
|
w = _live()
|
|
row = w.numbers["EQ"][no]
|
|
fuel = w.numbers["MO"][f"{row['값']['주연료종류']}:전국평균"]["키"]
|
|
crew = w.numbers["LB"][row["값"]["인력"][0]["키"].removeprefix("LB:")]["키"] # 842-3 인력 줄
|
|
return fuel, crew
|
|
|
|
|
|
# ── 수식 길 줄 쌓기 ───────────────────────────────────────────────────
|
|
@pytest.mark.parametrize("what", ["가격", "유가", "노임"])
|
|
def test_stack_m01_machine(world, monkeypatch, what):
|
|
"""품셈 기계(굴착기 1.0㎥) 줄 쌓기 → 저장 → 기계 가격 · 유가 · 조종원 노임 바뀜 →
|
|
금액 그대로."""
|
|
me = world["personal"]
|
|
key = _sk(me)
|
|
_stack(me, key, [("기계", MACHINE, "묶음")])
|
|
was = _sum(me, key)
|
|
assert was > 0
|
|
fuel, crew = _fuel_and_crew()
|
|
moved = {"가격": DIG, "유가": fuel, "노임": crew}[what]
|
|
_move(monkeypatch, moved)
|
|
now = _at(me, path.read, key)
|
|
assert now["셈"]["계"] == was
|
|
|
|
|
|
def test_stack_swapped_machine(world, monkeypatch):
|
|
"""바꿔 끼운 기계 — 기계 입력을 다른 굴착기로 바꿔 저장 → 그 기계 값이 사본에."""
|
|
me = world["personal"]
|
|
key = _sk(me)
|
|
_stack(me, key, [("기계", MACHINE, "묶음")])
|
|
got = _at(me, path.read, key)
|
|
doc = copy.deepcopy(got["문서"])
|
|
for v in doc["변수"]:
|
|
if (v.get("연결") or {}).get("키") == DIG_LOGIC:
|
|
v["연결"]["입력"] = {"기계": f"'{DIG2_NO}'"}
|
|
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
|
|
was = _sum(me, key)
|
|
other = _live().numbers["EQ"][DIG2_NO]["키"]
|
|
_move(monkeypatch, other)
|
|
assert _sum(me, key) == was
|
|
|
|
|
|
@pytest.mark.parametrize("kind", ["인력", "재료"])
|
|
def test_stack_resource(world, monkeypatch, kind):
|
|
"""자원 줄 더하기(노임 · 자재 요소) — 저장 뒤 값 바뀌어도 그대로."""
|
|
me = world["personal"]
|
|
res = MAN if kind == "인력" else next(iter(_live().index["MT"]))
|
|
key = _sk(me)
|
|
part = "노무비" if kind == "인력" else "재료비"
|
|
_stack(me, key, [("자원", {"갈래": "요소", "키": res}, part)])
|
|
was = _sum(me, key)
|
|
assert was > 0
|
|
_move(monkeypatch, res)
|
|
assert _sum(me, key) == was
|
|
|
|
|
|
def test_stack_logic_ref(world, monkeypatch):
|
|
"""단가산출 참조(M01 단가산출을 부름) — 그 식이 읽는 노임도 사본에."""
|
|
me = world["personal"]
|
|
key = _sk(me)
|
|
_stack(me, key, [("참조", {"갈래": "단가산출", "키": PCT, "입력": {}}, "묶음")])
|
|
was = _sum(me, key)
|
|
assert was > 0
|
|
_move(monkeypatch, MAN)
|
|
assert _sum(me, key) == was
|
|
|
|
|
|
# ── 옛 로직 길(더한줄 · 파생) ────────────────────────────────────────
|
|
OLD_ADDS = {
|
|
"로직 기계": ([{"종류": "로직", "로직": DIG_LOGIC, "입력값": {"기계": DIG_NO}, "수량": 1}],
|
|
{"기계": DIG_NO}, DIG),
|
|
"재료 요소": ([{"종류": "재료", "요소": "MT000008", "수량": 1}], {}, "MT000008"),
|
|
"인력 요소": ([{"종류": "인력", "요소": MAN, "수량": 1}], {}, MAN),
|
|
} # fmt: skip
|
|
|
|
|
|
# ── 가져온 식 · 층 복사 · 재생성 ──────────────────────────────────────
|
|
def test_imported_ours(world, monkeypatch):
|
|
"""가져온 식 단가기준 우리 — 이음 노임 바뀌어도 그대로 · 갱신 뒤 반영 · 엑셀 기준 = 엑셀 값."""
|
|
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
|
|
|
me = world["personal"]
|
|
man = {"종류": "인력", "이름": "보통인부", "단위": "인", "수량": "0.5", "비목": "노무비"}
|
|
row = {
|
|
"이름": "sub1임시 가져온",
|
|
"결과단위": "원/㎡",
|
|
"호표": [{**man, "단가": 165545, "이음": MAN}],
|
|
}
|
|
key = _at(me, lambda: imp.create(row, None, "sub1임시 가져온")["이름"])
|
|
assert _sum(me, key) == 82772 # 엑셀 단가 그대로
|
|
doc = _at(me, lambda: store.read("sangeun", key)["문서"])
|
|
ours = _at(me, lambda: imp.to_price(doc, "우리")["문서"])
|
|
_at(me, lambda: store.write("sangeun", key, store.read("sangeun", key)["판"], ours))
|
|
was = _sum(me, key)
|
|
_move(monkeypatch, MAN)
|
|
assert _sum(me, key) == was
|
|
|
|
|
|
def test_layer_copy_keeps_copy(world, monkeypatch):
|
|
"""층 복사(개인 → 회사) — 줄 쌓기 기계 사본째 · 원본 M01 값 바뀐 뒤 복사해도 그 값."""
|
|
me, co = world["personal"], world["company"]
|
|
key = _sk(me)
|
|
_stack(me, key, [("기계", MACHINE, "묶음")])
|
|
was = _sum(me, key)
|
|
_move(monkeypatch, DIG)
|
|
ref = {"층": "personal", "주인": "7/42", "키": key}
|
|
with store.at(co):
|
|
doc = refs.read_ref(ref)
|
|
new = refs.create("sangeun", refs.carry(refs.origin_mark(doc, ref), ("personal", "7/42")))
|
|
assert _sum(co, new["이름"]) == was
|
|
|
|
|
|
def test_gap_mark_then_save_fills(world, monkeypatch):
|
|
"""빈틈 있는 옛 SK — 열면 지금 값으로 셈 · 일괄 고쳐 쓰지 않음 ·
|
|
[저장] 하면 지금 값으로 굳음 · 그 뒤 M01 바뀌어도 그대로."""
|
|
me = world["personal"]
|
|
key = _sk(me)
|
|
_stack(me, key, [("기계", MACHINE, "묶음")])
|
|
file = me / "sangeun" / f"{key}.json"
|
|
raw = json.loads(file.read_text(encoding="utf-8"))
|
|
vals = raw["문서"]["수식"] if "문서" in raw else raw["수식"]
|
|
for part in ("로직", "단가"):
|
|
vals[part] = [] # 옛 저장본 흉내 — 줄 쌓기 기계를 사본에 안 박은 때
|
|
file.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8")
|
|
before = file.read_bytes()
|
|
was = _sum(me, key)
|
|
assert file.read_bytes() == before # 열기 = 안 고쳐 씀
|
|
files, live = m01.loaded()
|
|
_move(monkeypatch, DIG)
|
|
moved = _sum(me, key)
|
|
assert moved > was # 빈틈 = 지금 값으로 셈
|
|
got = _at(me, path.read, key)
|
|
_at(me, path.save, key, {"문서": got["문서"], "판": got["판"]})
|
|
assert _sum(me, key) == moved
|
|
monkeypatch.setattr(m01, "loaded", lambda: (files, live)) # 앞 값(절반)
|
|
assert _sum(me, key) == moved
|