- 기계 자료: M01 기계 221 대 값 칸 `작업량` = [{식 · 단위 · 변수(규격에서 정해지는 칸)}] (건설 공통 8-2 장 작업량 틀 · 빌더 build_기계_작업량_846_1.py · --check 0 · 다른 칸 · 시간당 비용 그대로)
- 계산기 짝 master_doc_work.py ↔ common_util_formula_doc_work.ts: 기계 줄 수량에서 시간당 작업량 자리 읽기(일당 = 시공량 ÷ (8 × 대수) · 식 = …/hr 나눔 변수) · 셈 답 줄 칸 `작업량` · 덮음 `작업량: {방식 시간당, 식, 변수?}` = 그 자리를 1 ÷ Q(기계 작업량 식)로 바꿔 셈 · 부착 기계(브레이커 · 집게) 줄 따로 · 식 없는 기계 · 단위 안 맞음 = 시간당 거절
- 덮음 짝(master_doc_cover · common_util_formula_doc_cover): 작업량은 기계 식 문서에 안 얹음 · prune 이 작업량 정리(일당 · 기본과 같은 변수 = 지움) · 몸 검사 · CoverEntry · CoverBase 꼴
- 저장 길: 사본 부름 묶음에 시간당 식 키(M02_Doc_Copy.calls) · 내 기계 clean 이 작업량 받음 · 연결 읽기 작업량 칸(master_doc_link)
- 기계 보기: 작업량 칸 = 제어 구역 몫(ownedCols — 바탕 칸 숫자 입력으로 안 그림 · 그리기는 846-2)
- 지킴: 1,520 문서 · 기계 655 대 · 견본 SK 금액 전후 다름 0 · 빌더 802-2 --check 1,520 같음(옵션 표본 18,873) · 둘 다 가능 줄 전수 시간당 셈 멈춤 0
- 시험: test_846_1_machine_work(일당 · 시간당 손셈 · E · K 덮음 · 정리 · 거절 · 부착 · 거울 · 저장 길 · 내 기계) 신설 · test_816_1 기대값 고침(까닭 — 4륜 덤프 1톤 기계 줄에 작업량 칸이 생겨 값 칸 비교에서 뺌)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
400 lines
18 KiB
Python
400 lines
18 KiB
Python
"""846-1 기계 줄 시간당 작업량 — 일당 읽기 · 시간당 방식 덮음 · 기계 작업량 칸 · 거울(파이썬 ↔ TS) 지킴 시험.
|
||
|
||
짝 = `resources/master_data/scripts/master_doc_work.py` ↔ `common_util/common_util_formula_doc_work.ts`
|
||
(계산기 부름 자리 = `master_doc_calc` ↔ `common_util_formula_doc_calc.ts` · 덮음 정리 = `master_doc_cover`).
|
||
① 터파기 보통토사 TypeⅠ(GC000088) 일당 = 지금 금액 · 시간당 작업량 = 560 ÷ 8 = 70 ㎥/hr.
|
||
② 시간당 방식 = 굴착기 1.0㎥ 8-2-3 식(GC001147) Q 로 나눈 금액 = 손셈 · E · K(버킷조건) 덮으면 그만큼.
|
||
③ 되돌리면(일당 · 기본과 같은 변수) 덮음 0 · 식 없는 기계 · 단위 안 맞음 = 시간당 거절.
|
||
④ 부착 기계(대형브레이커) 줄은 굴착기 시간당에 안 묶임 · 산림 문서(GF000099) 식 꼴도 바뀜.
|
||
⑤ 기계 작업량 칸(빌더 --check 0) · 사본 부름 묶음에 식 키 · 기계 식 문서는 그대로.
|
||
⑥ 거울 — 같은 연결 값으로 파이썬 · TS 금액 · 줄 · 작업량 답 · 자리 읽기 · 정리가 같음.
|
||
⑦ 저장 길(임시 층) — 시간당 저장 · 다시 열기 · 되돌리면 덮음 없음 · 거절 = 400.
|
||
"""
|
||
|
||
import copy as cp
|
||
import importlib
|
||
import json
|
||
import os
|
||
import subprocess
|
||
from decimal import Decimal as D
|
||
|
||
import pytest
|
||
|
||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||
|
||
mc = importlib.import_module("master_doc_calc")
|
||
ml = importlib.import_module("master_doc_link")
|
||
mcv = importlib.import_module("master_doc_cover")
|
||
mw = importlib.import_module("master_doc_work")
|
||
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
NO = "0201-0100" # 굴착기(무한궤도) 1.0㎥
|
||
DIG = "GC000088" # 터파기(기계) 보통토사 — 건설 공통 3-2-4
|
||
TPL = "GC001147" # 굴착기 시간당 작업량 — 건설 공통 8-2-3
|
||
HOURLY = {NO: {mw.WORK: {"방식": "시간당", "식": TPL}}}
|
||
COSTS = ("노무비", "재료비", "경비")
|
||
|
||
|
||
@pytest.fixture(scope="module")
|
||
def links():
|
||
return ml.Links(m01.loaded()[1])
|
||
|
||
|
||
def _with(doc: dict, cover: dict | None) -> dict:
|
||
return {**doc, mcv.COVER: cover} if cover else doc
|
||
|
||
|
||
def _line(ans: dict, name: str) -> dict:
|
||
return next(x for x in ans["줄"] if x["이름"] == name)
|
||
|
||
|
||
def _cut(v: D) -> D:
|
||
return D(str(mc.rounddown(float(v), 1)))
|
||
|
||
|
||
def _q(links, *, e: D | None = None, bucket: str | None = None) -> D:
|
||
"""GC001147 손셈 — q 1.0 · 규격 1.0∼1.2 · 선회 135° · K(버킷조건) · E(흐트러진 · 보통 · 모래) · f 0.7."""
|
||
tpl = links.doc(TPL)
|
||
opts = {v["열쇠"]: v["연결"] for v in tpl["변수"]}
|
||
k = links.table(
|
||
{"표": "CC000042", "조건": {"현장조건": bucket or opts["버킷조건"]["값"]}, "칸": "K"}
|
||
)
|
||
if e is None:
|
||
e = links.table(
|
||
{"표": "CC000043", "칸": "E",
|
||
"조건": {"현장조건": "흐트러진 상태", "등급": "보통", "토질명": "모래, 사질토"}}
|
||
) # fmt: skip
|
||
cm = links.table({"표": "CC000045", "조건": {"규격": "1.0∼1.2", "각도": D(135)}, "칸": "시간"})
|
||
q = D(3600) * D(1) * D(str(k)) * D("0.7") * D(str(e)) / D(str(cm))
|
||
return q.quantize(D("0.001"), rounding="ROUND_HALF_UP")
|
||
|
||
|
||
# ── ① 일당 ─────────────────────────────────────────────────────────────
|
||
def test_터파기_일당_지금_금액_시간당_작업량_70(links):
|
||
ans = mc.calc(links.doc(DIG), links)
|
||
line = _line(ans, "굴착기")
|
||
work = line[mw.WORK]
|
||
assert work == {"기계": NO, "꼴": "일당", "율": "Q_시공 ÷ (8 × Q_굴착기^표)", "값": D(70),
|
||
"단위": "㎥/hr", "식들": [TPL]} # fmt: skip
|
||
price = line["단가"]
|
||
want = {k: _cut(price[k] * 1 * 8 / D(560)) for k in COSTS} # 대수 1 × 8 ÷ 560
|
||
assert line["비목"] == want and ans["셈됨"]
|
||
|
||
|
||
def test_덮음_없음_남의_기계_덮음_금액_같음(links):
|
||
doc = links.doc(DIG)
|
||
base = mc.calc(doc, links)
|
||
other = mc.calc(_with(doc, {"0201-0060": {mw.WORK: {"방식": "시간당", "식": TPL}}}), links)
|
||
assert [x["금액"] for x in base["줄"]] == [x["금액"] for x in other["줄"]]
|
||
assert base["계"] == other["계"]
|
||
|
||
|
||
# ── ② 시간당 ───────────────────────────────────────────────────────────
|
||
def test_시간당_식_Q_로_나눈_금액_손셈(links):
|
||
ans = mc.calc(_with(links.doc(DIG), HOURLY), links)
|
||
line = _line(ans, "굴착기")
|
||
q = _q(links)
|
||
assert line[mw.WORK]["꼴"] == "시간당" and line[mw.WORK]["값"] == q
|
||
assert line[mw.WORK]["변수"]["버킷용량"] == 1 and line[mw.WORK]["변수"]["f"] == D("0.7")
|
||
assert line["비목"] == {k: _cut(line["단가"][k] / q) for k in COSTS}
|
||
assert line["수량"] == 1 / q and ans["셈됨"]
|
||
|
||
|
||
def test_시간당_E_K_덮으면_그만큼(links):
|
||
tpl = links.doc(TPL)
|
||
first = next(v for v in tpl["변수"] if v["열쇠"] == "버킷조건")["연결"]["목록"][0]
|
||
want = {"방식": "시간당", "식": TPL, "변수": {"E입력": 0.5, "버킷조건": first}}
|
||
ans = mc.calc(_with(links.doc(DIG), {NO: {mw.WORK: want}}), links)
|
||
line = _line(ans, "굴착기")
|
||
q = _q(links, e=D("0.5"), bucket=first)
|
||
assert q != _q(links) and line[mw.WORK]["값"] == q
|
||
assert line["비목"] == {k: _cut(line["단가"][k] / q) for k in COSTS}
|
||
|
||
|
||
# ── ③ 정리 · 거절 ──────────────────────────────────────────────────────
|
||
def test_되돌리면_덮음_0(links):
|
||
doc = links.doc(DIG)
|
||
assert mcv.COVER not in mcv.prune_doc(_with(doc, {NO: {mw.WORK: {"방식": "일당"}}}), links)
|
||
same = {"방식": "시간당", "식": TPL, "변수": {"f": 0.7, "버킷용량": 1, "선회각도": 135}}
|
||
got = mcv.prune_doc(_with(doc, {NO: {mw.WORK: same}}), links)[mcv.COVER]
|
||
assert got == {NO: {mw.WORK: {"방식": "시간당", "식": TPL}}} # 기본과 같은 변수 = 뺌
|
||
moved = {**same, "변수": {"f": 0.8, "버킷용량": 1}}
|
||
got = mcv.prune_doc(_with(doc, {NO: {mw.WORK: moved}}), links)[mcv.COVER]
|
||
assert got[NO][mw.WORK]["변수"] == {"f": 0.8}
|
||
|
||
|
||
def _first_machine(links, key: str, name: str) -> str:
|
||
return _line(mc.calc(links.doc(key), links), name)[mw.WORK]["기계"]
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
("key", "name", "why"),
|
||
[
|
||
("GC000007", "크레인", "작업량 식 없는 기계"),
|
||
("GC000112", "굴착기 0.2㎥", "맞는 작업량 식 없음"),
|
||
],
|
||
)
|
||
def test_시간당_거절(links, key, name, why):
|
||
no = _first_machine(links, key, name)
|
||
want = {"방식": "시간당", "식": TPL}
|
||
ans = mc.calc(_with(links.doc(key), {no: {mw.WORK: want}}), links)
|
||
line = _line(ans, name)
|
||
assert line["금액"] is None and why in line[mw.WORK]["까닭"] and not ans["셈됨"]
|
||
assert any(m["갈래"] == "시간당 거절" for m in ans["표지"])
|
||
if why == "작업량 식 없는 기계":
|
||
with pytest.raises(ValueError):
|
||
mcv.prune_doc(_with(links.doc(key), {no: {mw.WORK: want}}), links)
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
"bad",
|
||
[{"방식": "주당"}, {"방식": "시간당"}, {"방식": "시간당", "식": 3},
|
||
{"방식": "시간당", "식": TPL, "변수": {"f": [1]}}],
|
||
) # fmt: skip
|
||
def test_몸_검사_틀림(bad):
|
||
with pytest.raises(ValueError):
|
||
mcv.clean({NO: {mw.WORK: bad}})
|
||
|
||
|
||
# ── ④ 부착 기계 · 산림 식 꼴 ────────────────────────────────────────────
|
||
def test_부착_브레이커_줄은_굴착기_시간당에_안_묶임(links):
|
||
doc = links.doc("GC000087")
|
||
base = mc.calc(doc, links)
|
||
got = mc.calc(_with(doc, HOURLY), links)
|
||
rows = {x["이름"]: (x, y) for x, y in zip(base["줄"], got["줄"])}
|
||
dig, brk = rows["굴착기 1.0㎥"], rows["대형브레이커 1.0㎥(굴착기 1.0㎥ 부착)"]
|
||
assert brk[0][mw.WORK]["기계"] != NO and brk[0][mw.WORK]["식들"] == []
|
||
assert brk[0]["금액"] == brk[1]["금액"] # 브레이커 = 일당 그대로
|
||
assert dig[1][mw.WORK]["꼴"] == "시간당" and dig[1]["금액"] != dig[0]["금액"]
|
||
|
||
|
||
def test_산림_식_꼴_시간당(links):
|
||
doc = links.doc("GF000099")
|
||
base = mc.calc(doc, links)
|
||
name = "굴착기(무한궤도) 0.7㎥"
|
||
old = _line(base, name)
|
||
assert old[mw.WORK]["꼴"] == "식" and old[mw.WORK]["율"] == "Q_작업"
|
||
no = old[mw.WORK]["기계"]
|
||
got = _line(mc.calc(_with(doc, {no: {mw.WORK: {"방식": "시간당", "식": TPL}}}), links), name)
|
||
q = got[mw.WORK]["값"]
|
||
assert got["수량"] == base["값"]["r_기계"] / 100 / q # 기계 비율(90%)은 곱에 남음
|
||
|
||
|
||
# ── ⑤ 기계 칸 · 부름 · 기계 식 문서 ────────────────────────────────────
|
||
def test_기계_작업량_칸(links):
|
||
row = links.master.get(f"EQ:{NO}")
|
||
assert row["값"][mw.WORK] == [{"식": TPL, "단위": "㎥/hr", "변수": {"버킷용량": 1, "규격구분": "1.0∼1.2"}}] # fmt: skip
|
||
assert row["출처"][mw.WORK] == "건설품셈 공통 8-2-3" and row["단위"][mw.WORK] == ""
|
||
build = importlib.import_module("build_기계_작업량_846_1")
|
||
seen = build.main("--check")
|
||
assert seen["어긋남(--check)"] == 0 and seen["작업량 칸 있음"] == 221
|
||
|
||
|
||
def test_사본_부름에_식_키_기계_식_문서_그대로(links):
|
||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||
|
||
doc = _with(links.doc(DIG), HOURLY)
|
||
assert TPL in dc.calls(doc) and TPL not in dc.calls(links.doc(DIG))
|
||
cost = links.doc("GC000267")
|
||
assert mcv.cover_doc(cost, {"기계": NO}, HOURLY) is cost
|
||
|
||
|
||
# ── ⑥ 거울 ────────────────────────────────────────────────────────────
|
||
def _canon(v):
|
||
if isinstance(v, (D, int, float)) and not isinstance(v, bool):
|
||
return mc.plain_text(D(str(v)))
|
||
if isinstance(v, list):
|
||
return [_canon(x) for x in v]
|
||
if isinstance(v, dict):
|
||
return {k: _canon(v[k]) for k in sorted(v)}
|
||
return v
|
||
|
||
|
||
class Rec:
|
||
def __init__(self, links):
|
||
self.links, self.log, self.docs = links, {}, {}
|
||
|
||
def _keep(self, kind, p, fn):
|
||
key = f"{kind}|{json.dumps(_canon(p), ensure_ascii=False, separators=(',', ':'))}"
|
||
try:
|
||
got = fn(p)
|
||
except mc.Gap as e:
|
||
self.log[key] = {"빈": str(e)}
|
||
raise
|
||
except mc.Broken as e:
|
||
self.log[key] = {"끊김": str(e)}
|
||
raise
|
||
self.log[key] = {"값": got}
|
||
return got
|
||
|
||
def element(self, p):
|
||
return self._keep("요소", p, self.links.element)
|
||
|
||
def table(self, p):
|
||
return self._keep("표", p, self.links.table)
|
||
|
||
def doc(self, key):
|
||
got = self.docs[key] = self.links.doc(key)
|
||
return got
|
||
|
||
|
||
def _same(a, b, where=""):
|
||
if isinstance(a, dict):
|
||
assert isinstance(b, dict) and set(a) == set(b), (where, sorted(a), sorted(b or {}))
|
||
for k in a:
|
||
_same(a[k], b[k], f"{where}.{k}")
|
||
elif isinstance(a, list):
|
||
assert isinstance(b, list) and len(a) == len(b), (where, a, b)
|
||
for i, (x, y) in enumerate(zip(a, b)):
|
||
_same(x, y, f"{where}[{i}]")
|
||
elif isinstance(a, (D, int, float)) and not isinstance(a, bool):
|
||
assert isinstance(b, (int, float)) and not isinstance(b, bool), (where, a, b)
|
||
assert float(a) == pytest.approx(b, rel=1e-9, abs=1e-9), (where, a, b)
|
||
else:
|
||
assert a == b, (where, a, b)
|
||
|
||
|
||
def _lines(ans: dict) -> list:
|
||
return [{k: x.get(k) for k in ("이름", "수량", "금액", mw.WORK)} for x in ans.get("줄") or []]
|
||
|
||
|
||
TEXTS = [
|
||
"Q_굴착기^표 × 8 ÷ Q_시공",
|
||
"만약(Type == 'TypeⅢ', 0, Q_굴착기^표 × 8 ÷ Q_시공)",
|
||
"r_기계 ÷ 100 × 8 ÷ Q_시공",
|
||
"2 × Q_굴착기^표 × 8 ÷ (Q_시공 × 1.1)",
|
||
"d_장비 × 8",
|
||
"",
|
||
]
|
||
|
||
|
||
def test_거울_파이썬_TS_같은_답(links):
|
||
rec = Rec(links)
|
||
no_spec = _first_machine(links, "GC000007", "크레인")
|
||
gf = _first_machine(links, "GF000099", "굴착기(무한궤도) 0.7㎥")
|
||
first = next(v for v in links.doc(TPL)["변수"] if v["열쇠"] == "버킷조건")["연결"]["목록"][0]
|
||
picks = [
|
||
(DIG, None),
|
||
(DIG, HOURLY),
|
||
(DIG, {NO: {mw.WORK: {"방식": "시간당", "식": TPL, "변수": {"E입력": 0.5, "버킷조건": first}}}}),
|
||
("GC000087", HOURLY),
|
||
("GC000090", HOURLY),
|
||
("GF000099", {gf: {mw.WORK: {"방식": "시간당", "식": TPL}}}),
|
||
("GX000004", {"0201-0070": {mw.WORK: {"방식": "시간당", "식": TPL}}}),
|
||
("GC000007", {no_spec: {mw.WORK: {"방식": "시간당", "식": TPL}}}),
|
||
("GC000112", {_first_machine(links, "GC000112", "굴착기 0.2㎥"): {mw.WORK: {"방식": "시간당", "식": TPL}}}),
|
||
("GC000085", None),
|
||
] # fmt: skip
|
||
cases, want = [], []
|
||
for key, cover in picks:
|
||
doc = links.doc(key)
|
||
cases.append({"문서": doc, "덮음": cover})
|
||
want.append(mc.calc(_with(doc, cover), rec))
|
||
texts = [{"문서": links.doc(DIG), "수량": t} for t in TEXTS]
|
||
text_want = [
|
||
{"자리": [{"꼴": s["꼴"], "율": s["율"], "단위": s["단위"]} for s in mw.sites(x["문서"], x["수량"])],
|
||
"바꿈": mw.swap(x["문서"], x["수량"])}
|
||
for x in texts
|
||
] # fmt: skip
|
||
prunes = [
|
||
{
|
||
"덮음": {"방식": "시간당", "식": TPL, "변수": {"f": 0.7, "E입력": 0.4}},
|
||
"기본": {"f": 0.7},
|
||
},
|
||
{"덮음": {"방식": "일당"}, "기본": None},
|
||
{"덮음": {"방식": "시간당", "식": TPL}, "기본": {}},
|
||
]
|
||
prune_want = [mw.prune_work(x["덮음"], x["기본"]) for x in prunes]
|
||
payload = {"문서들": rec.docs, "대상": cases, "기록": rec.log, "글": texts, "정리": prunes}
|
||
proc = subprocess.run(
|
||
["node", os.path.join(HERE, "helper_846_1_machine_work.cjs")],
|
||
input=json.dumps(ml._norm(payload), ensure_ascii=False),
|
||
capture_output=True,
|
||
text=True,
|
||
encoding="utf-8",
|
||
check=True,
|
||
)
|
||
got = json.loads(proc.stdout)
|
||
for i, (a, b) in enumerate(zip(want, got["답"])):
|
||
_same(ml._norm({k: a.get(k) for k in (*COSTS, "계", "셈됨")}),
|
||
{k: b.get(k) for k in (*COSTS, "계", "셈됨")}, f"답{i}") # fmt: skip
|
||
_same(ml._norm(_lines(a)), _lines(b), f"줄{i}")
|
||
assert [m["갈래"] for m in a["표지"]] == [m["갈래"] for m in b["표지"]], i
|
||
_same(text_want, got["글"], "글")
|
||
_same(ml._norm(prune_want), got["정리"], "정리")
|
||
_same([mw.cover_calls({mcv.COVER: c["덮음"]}) for c in cases], got["부름"], "부름")
|
||
assert text_want[0]["바꿈"] == "1 ÷ Q_시간당작업량"
|
||
assert text_want[2]["바꿈"] == "r_기계 ÷ 100 ÷ Q_시간당작업량"
|
||
assert text_want[4]["자리"] == []
|
||
|
||
|
||
# ── ⑦ 저장 길(임시 층 · 수식 길) ────────────────────────────────────────
|
||
@pytest.fixture
|
||
def world(tmp_path, monkeypatch):
|
||
from resources.tester.test_m02_labor_ref import world as make
|
||
|
||
return make.__wrapped__(tmp_path, monkeypatch)
|
||
|
||
|
||
def test_저장_다시_열기_되돌리면_덮음_없음(world, links):
|
||
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
|
||
|
||
me = world["personal"]
|
||
|
||
def at(fn, *args):
|
||
with store.at(me):
|
||
return fn(*args)
|
||
|
||
key = at(
|
||
lambda: refs.create("sangeun", {"이름": "sub2임시 작업량", "단위": "㎥", "더한줄": []})
|
||
)
|
||
key = key["이름"]
|
||
got = at(path.read, key)
|
||
doc = cp.deepcopy(got["문서"])
|
||
doc.setdefault("변수", []).append(
|
||
{"기호": "P", "아래": "터파기", "위": "", "이름": "터파기", "단위": "",
|
||
"연결": {"갈래": "단가산출", "키": DIG, "입력": {}}}
|
||
) # fmt: skip
|
||
doc.setdefault("금액", []).append(
|
||
{"이름": "터파기", "단위": "㎥", "비목": "묶음", "수량": "1", "단가": "P_터파기"}
|
||
)
|
||
base = at(path.save, key, {"문서": doc, "판": got["판"]})
|
||
was = base["셈"]["계"]
|
||
assert was == mc.calc(links.doc(DIG), links)["계"]
|
||
doc = cp.deepcopy(base["문서"])
|
||
doc[mcv.COVER] = {**HOURLY, "9999-9999": {mw.WORK: {"방식": "시간당", "식": TPL}}}
|
||
after = at(path.save, key, {"문서": doc, "판": base["판"]})
|
||
assert after["문서"][mcv.COVER] == HOURLY # 안 부르는 기계 = 뺌
|
||
assert TPL in after["부름"]
|
||
hand = mc.calc(_with(links.doc(DIG), HOURLY), links)["계"]
|
||
assert after["셈"]["계"] == hand != was
|
||
again = at(path.read, key)
|
||
assert again["셈"]["계"] == hand and again["문서"][mcv.COVER] == HOURLY
|
||
doc = cp.deepcopy(again["문서"])
|
||
doc[mcv.COVER] = {NO: {mw.WORK: {"방식": "일당"}}}
|
||
back = at(path.save, key, {"문서": doc, "판": again["판"]})
|
||
assert mcv.COVER not in back["문서"] and back["셈"]["계"] == was
|
||
doc[mcv.COVER] = {NO: {mw.WORK: {"방식": "시간당"}}} # 식 키 없음 = 거절
|
||
with pytest.raises(store.StoreError):
|
||
at(path.save, key, {"문서": doc, "판": back["판"]})
|
||
|
||
|
||
def test_내_기계_작업량_칸_받음(world):
|
||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||
from M02_MasterTemplete import M02_MyMachine as mym
|
||
|
||
me = world["personal"]
|
||
with store.at(me):
|
||
row = mym.create({"방식": "바로"}, "EQ000022")["줄"]
|
||
hour = mh.hourly(row["키"])
|
||
assert row["값"][mw.WORK] == [{"식": TPL, "단위": "㎥/hr", "변수": {"버킷용량": 1, "규격구분": "1.0∼1.2"}}] # fmt: skip
|
||
assert hour["계"] == mh.hourly("EQ000022")["계"] # 시간당 비용은 안 바뀜
|
||
for bad in ([{"식": DIG}], [{"식": TPL, "변수": {"f": [1]}}], "작업량"):
|
||
with pytest.raises(store.StoreError):
|
||
mym.create({"방식": "바로", "값": {mw.WORK: bad}}, "EQ000022")
|
||
none = mym.create({"방식": "바로", "값": {mw.WORK: []}}, "EQ000022")["줄"]
|
||
assert mw.WORK not in none["값"]
|