Merge remote-tracking branches 'origin/main_laptop_1' and 'origin/sub_laptop_8' into sub_laptop_3
This commit is contained in:
@@ -0,0 +1,54 @@
|
||||
{
|
||||
"갈래": {
|
||||
"precombo.고치기": "600ec92b1b7fabe4",
|
||||
"precombo.나무": "d08cff9db9575c99",
|
||||
"precombo.되돌림": "ce11ade1bd96129c",
|
||||
"precombo.만들기": "e53ad45acbf386bc",
|
||||
"precombo.목록": "20bd9f3f0803cb91",
|
||||
"precombo.복사": "ea957146cf361b70",
|
||||
"precombo.붙여넣기": "236bf55301ef9045",
|
||||
"precombo.쓰는곳": "8f68c3d2501f7a53",
|
||||
"precombo.읽기": "c822ceb7cedfc59d",
|
||||
"precombo.중복": "6f783eab99eb8095",
|
||||
"precombo.지우기": "a356d2496ae34f51",
|
||||
"precombo.합치기": "2010fbd1ab774d86",
|
||||
"sangeun.고치기": "e47e5593c71f5a56",
|
||||
"sangeun.나무": "991823a8c1fe1913",
|
||||
"sangeun.되돌림": "6ca25af01d1d38ab",
|
||||
"sangeun.만들기": "2155d280fd6d97ae",
|
||||
"sangeun.목록": "a75cf0387e16ed84",
|
||||
"sangeun.복사": "40edbd4d0644186f",
|
||||
"sangeun.붙여넣기": "57cfb7bb522a80d3",
|
||||
"sangeun.쓰는곳": "2c9ec1824709481f",
|
||||
"sangeun.읽기": "6f5b02af37f2b55b",
|
||||
"sangeun.중복": "e4d3ff3235a8d0b9",
|
||||
"sangeun.지우기": "db8b1e8ad9bef9eb",
|
||||
"sangeun.합치기": "5a6d9e24d05ae1af",
|
||||
"공유.거절": "9a38b16329ed7c68",
|
||||
"공유.목록": "eccff54e8114d69c",
|
||||
"공유.봄": "a3bdb64cc1be2935",
|
||||
"공유.승인": "ec5183ff8c81f5c8",
|
||||
"공유.요청": "762ba10d5af57643",
|
||||
"권한.같은회사남": "2d3d50a90583497d",
|
||||
"권한.남의회사관리": "a1213c908c70528f",
|
||||
"권한.시스템": "ee1c88a183b2740f",
|
||||
"권한.일반": "9a05899de41301f2",
|
||||
"권한.회사관리": "d6da88af7fe80323",
|
||||
"내기계.고치기": "3f00365dbfb77cee",
|
||||
"내기계.만들기": "20f5562f02c276f8",
|
||||
"내기계.목록": "064102da4c9740d6",
|
||||
"내기계.쓰는곳": "7bd823f7780c6f86",
|
||||
"내기계.읽기": "0e5467fc806d83ff",
|
||||
"내기계.지우기": "6db3b2b387f87ce7",
|
||||
"내기계.찾기": "feca2de012a206ee",
|
||||
"내재료.고치기": "60c0d3337d7dde06",
|
||||
"내재료.만들기": "9fec4ce2a9bbfb82",
|
||||
"내재료.목록": "9c5929426719e9ae",
|
||||
"내재료.지우기": "9c194d1b5367920e",
|
||||
"항목.나무": "abb5815352e81102",
|
||||
"항목.목록": "f7ff1a6372bf308f",
|
||||
"항목.복사": "b37ed4bfc45e5032",
|
||||
"항목.붙여넣기": "2324914f36f4b24e",
|
||||
"항목.지우기": "1fd673b8f7e3bab1"
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,301 @@
|
||||
"""857-0 지킴 도우미 — 불러오기 지문(블록 × 두 판 · 검산 · 이음 / 엑셀 올림 · 호표 목록 · 칠 ·
|
||||
고정 줄 / 재료 이음 표).
|
||||
|
||||
- 블록 = 견본(원파일 EST · STC · 실무 엑셀)마다 `Doc_FromNative.emit` → 가져온 식 SK(저장 없음) →
|
||||
엑셀 판 · 우리 판 문서 셈(`Doc_Import.derive` + `run`) 노 · 재 · 경 · 계 +
|
||||
검산(`Sangeun_Imported.check` 같음 · 줄 같음 수) + 줄마다 이음(종류 · 이음 · 기계 찾기 ·
|
||||
재료 찾기 판정 · 키).
|
||||
- 올림 = 엑셀을 임시 개인 층에 올림(`Hopyo_Router._upload`) → 거절 글 | 목록(`Hopyo_View.listing`) ·
|
||||
칠(`Hopyo_Marks.blocks`) · 고정 줄(`Hopyo_Fixed.line_of` 이름 · 규격 · 단위 · 단가 · 이음 · 비율).
|
||||
- 재료 이음 표 = 일위대가 호표 자재 · 별도계상 줄 — 호표 길 키(`line_of`) ·
|
||||
단가산출 길 키(`San_Link.m01`).
|
||||
- 지문 = 갈래 열쇠(「블록 EST:거창#3」 등)마다 sha256 앞 16 자 · 견본 내용은 안 남김.
|
||||
- M01 한 벌 쥠(셈 동안 M01 파일이 안 바뀜 — 빠르게만 · 답 같음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import hashlib
|
||||
import json
|
||||
import sys
|
||||
import tempfile
|
||||
import warnings
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
warnings.filterwarnings("ignore", category=UserWarning, module="openpyxl")
|
||||
|
||||
KEYS = ("노무비", "재료비", "경비", "계")
|
||||
#: 기본(빠른) 표본 — 견본마다 블록 몇 개 · 올림 파일 몇 개(전수 = `S857_ALL=1`)
|
||||
QUICK_BLOCKS = {
|
||||
"EST:거창": 8,
|
||||
"STC:봉화": 8,
|
||||
"엑셀:북부청임도": 8,
|
||||
"엑셀:봉화": 8,
|
||||
"엑셀:2026수목": 8,
|
||||
}
|
||||
QUICK_UPLOAD = ("북부청임도", "봉화", "2026수목")
|
||||
|
||||
|
||||
def sources() -> dict[str, Path]:
|
||||
"""「갈래:이름」 → 견본 경로(없는 PC = 경로가 없음)."""
|
||||
import test_797_1a_import_flags as practice
|
||||
from test_810_1_estx import FILES as EST
|
||||
from test_810_1_stc import FILES as STC
|
||||
|
||||
out = {f"EST:{k}": v for k, v in EST.items()}
|
||||
out |= {f"STC:{k}": v for k, v in STC.items()}
|
||||
return out | {f"엑셀:{k}": v for k, v in practice.FILES.items()}
|
||||
|
||||
|
||||
def digest(value: Any) -> str:
|
||||
raw = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
|
||||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def hold_m01():
|
||||
"""M01 한 벌을 셈 동안 쥠(줄마다 파일 날짜 다시 재기 뺌)."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
real, memo = m01.loaded, []
|
||||
|
||||
def once():
|
||||
if not memo:
|
||||
memo.append(real())
|
||||
return memo[0]
|
||||
|
||||
m01.loaded = once
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
m01.loaded = real
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def personal():
|
||||
"""임시 storage 개인 층(원본 storage · 마스터 안 씀)."""
|
||||
from config import config_system
|
||||
|
||||
old = config_system.STORAGE_BASE_DIR
|
||||
tmp = Path(tempfile.mkdtemp(prefix="t857_"))
|
||||
config_system.STORAGE_BASE_DIR = str(tmp / "storage")
|
||||
(tmp / "storage").mkdir()
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
|
||||
folder = layers.personal_dir(7, 42)
|
||||
folder.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
with store.at(folder):
|
||||
yield folder
|
||||
finally:
|
||||
config_system.STORAGE_BASE_DIR = old
|
||||
|
||||
|
||||
# ── 블록 ──────────────────────────────────────────────────────────────
|
||||
def saved_of(tag: str, path: Path) -> dict:
|
||||
from M02_MasterTemplete import M02_Doc_FromNative as fn
|
||||
from M02_MasterTemplete import M02_San_Xlsx as sx
|
||||
|
||||
raw = path.read_bytes()
|
||||
if tag.startswith("엑셀:"):
|
||||
return fn.pack(sx.read(path.name, raw), path.name)
|
||||
return fn.read(path.name, raw)
|
||||
|
||||
|
||||
def _money(got: dict) -> Any:
|
||||
return {k: str(got.get(k)) for k in KEYS} if got.get("셈됨") else "못 셈"
|
||||
|
||||
|
||||
def _links(row: dict) -> list:
|
||||
out = []
|
||||
for it in row.get("호표") or []:
|
||||
res = it.get("자원") or {}
|
||||
find, mat = res.get("찾기") or {}, res.get("재료찾기") or {}
|
||||
out.append(
|
||||
[
|
||||
it.get("종류"),
|
||||
it.get("이음"),
|
||||
find.get("판정"),
|
||||
find.get("키"),
|
||||
mat.get("판정"),
|
||||
mat.get("키"),
|
||||
]
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def block(saved: dict, no: int) -> dict:
|
||||
"""블록 하나 → 지문 몸 {엑셀, 우리, 검산, 이음}."""
|
||||
from M02_MasterTemplete import M02_Doc_FromNative as fn
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
|
||||
whole = imp._whole()
|
||||
out = fn.emit(saved, no)
|
||||
row = out["로직"]
|
||||
sk = {
|
||||
"키": "SK-999999",
|
||||
"이름": row["이름"],
|
||||
"단위": str(row.get("결과단위", "/")).split("/", 1)[-1],
|
||||
}
|
||||
sk |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []}
|
||||
sk[imp.KEY] = {"로직": row, "원본": out["원본"], "단가기준": "엑셀"}
|
||||
sk = sd.clean(sk, None, whole)
|
||||
got: dict[str, Any] = {"이음": _links(row)}
|
||||
for basis in ("엑셀", "우리"):
|
||||
one = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": basis}}
|
||||
try:
|
||||
got[basis] = _money(dim.run(dim.derive(one, None, whole), one, whole))
|
||||
except Exception as e: # noqa: BLE001 — 예외도 지문
|
||||
got[basis] = f"예외 {type(e).__name__}"
|
||||
try:
|
||||
c = imp.check(sk, whole)
|
||||
got["검산"] = [c["같음"], sum(1 for x in c["줄"] if x.get("같음")), len(c["줄"])]
|
||||
except Exception as e: # noqa: BLE001
|
||||
got["검산"] = f"예외 {type(e).__name__}"
|
||||
return got
|
||||
|
||||
|
||||
def blocks(full: bool) -> tuple[dict[str, str], int]:
|
||||
"""{「블록 갈래:이름#번」: 지문} · 건너뛴 견본 수."""
|
||||
from M02_MasterTemplete import M02_Doc_FromNative as fn
|
||||
|
||||
out, skipped = {}, 0
|
||||
with hold_m01(), personal():
|
||||
for tag, path in sources().items():
|
||||
if not full and tag not in QUICK_BLOCKS:
|
||||
continue
|
||||
if not path or not path.exists():
|
||||
skipped += 1
|
||||
continue
|
||||
saved = saved_of(tag, path)
|
||||
nos = sorted(fn.numbers(saved))
|
||||
if not full:
|
||||
step = max(1, len(nos) // QUICK_BLOCKS[tag])
|
||||
nos = nos[::step][: QUICK_BLOCKS[tag]]
|
||||
for no in nos:
|
||||
out[f"블록 {tag}#{no}"] = digest(block(saved, no))
|
||||
return out, skipped
|
||||
|
||||
|
||||
# ── 엑셀 올림 · 호표 쪽 ─────────────────────────────────────────────────
|
||||
def _fixed(book: dict) -> list:
|
||||
from M02_MasterTemplete import M02_Hopyo_Fixed as hf
|
||||
|
||||
linker, out = hf.Linker(True), []
|
||||
for h in book.get("호표") or []:
|
||||
for ln in h.get("줄") or []:
|
||||
fx = hf.line_of(ln, h["줄"], {}, set(), linker)["고정"]
|
||||
out.append(
|
||||
[
|
||||
h["번"],
|
||||
ln.get("차례"),
|
||||
{k: fx.get(k) for k in ("이름", "규격", "단위", "단가", "이음", "비율")},
|
||||
]
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def mats(book: dict, clues: list) -> list:
|
||||
"""재료 이음 표 [호표, 차례, 갈래, 호표 길 키, 단가산출 길 키, 산근 판정 · 방법]."""
|
||||
from M02_MasterTemplete import M02_Hopyo_Fixed as hf
|
||||
from M02_MasterTemplete import M02_Hopyo_Match as hm
|
||||
from M02_MasterTemplete import M02_San_Link as sl
|
||||
from M02_MasterTemplete import M02_San_MatFind as smf
|
||||
|
||||
linker, out = hf.Linker(True), []
|
||||
for h in book.get("호표") or []:
|
||||
for ln in h.get("줄") or []:
|
||||
if hf.kind_of(ln) not in hm.MATERIAL_KINDS:
|
||||
continue
|
||||
a = (hf.line_of(ln, h["줄"], {}, set(), linker)["고정"]["이음"] or {}).get("자재")
|
||||
src = {k: ln.get(k) or "" for k in ("이름", "규격", "단위")}
|
||||
src |= {"종류": "자재", "코드": ln.get("코드") or ""}
|
||||
with smf.clues_on(clues):
|
||||
b, _ = sl.m01("재료", src, "")
|
||||
found = src.get("재료찾기") or {}
|
||||
out.append(
|
||||
[
|
||||
h["번"],
|
||||
ln.get("차례"),
|
||||
ln.get("갈래"),
|
||||
a,
|
||||
b,
|
||||
found.get("판정"),
|
||||
found.get("방법"),
|
||||
]
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def upload(tag: str, path: Path) -> dict[str, Any]:
|
||||
"""엑셀 하나 올림(임시 층) → {올림, 목록, 칠, 고정, 재료} 지문 몸."""
|
||||
from M02_MasterTemplete import M02_Doc_FromNative as fn
|
||||
from M02_MasterTemplete import M02_Hopyo_Marks as marks
|
||||
from M02_MasterTemplete import M02_Hopyo_Router as router
|
||||
from M02_MasterTemplete import M02_Hopyo_Store as hstore
|
||||
from M02_MasterTemplete import M02_Hopyo_View as view
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_San_Book as sb
|
||||
from M02_MasterTemplete import M02_San_Xlsx as sx
|
||||
|
||||
data = path.read_bytes()
|
||||
try:
|
||||
row = router._upload(path.name, data, {"id": 42, "이름": "시험"})
|
||||
except store.StoreError as e:
|
||||
return {"올림": f"거절 {e.status} {e}"}
|
||||
folder, key = store.root(), row["키"]
|
||||
book = hstore.read(folder, key)
|
||||
listing = view.listing(folder, key, folder)
|
||||
sheets = sb.sheets(path.name, data)
|
||||
clues = (fn.pack(sx.read_sheets(sheets), path.name) if sb.kind_of(sheets) else {}).get("단서")
|
||||
return {
|
||||
"올림": {k: row.get(k) for k in ("시트", "호표수", "읽기불가")},
|
||||
"목록": {k: listing.get(k) for k in ("호표", "단산", "검산")},
|
||||
"칠": marks.blocks(folder, key),
|
||||
"고정": _fixed(book),
|
||||
"재료": mats(book, clues or []),
|
||||
}
|
||||
|
||||
|
||||
def uploads(full: bool) -> tuple[dict[str, str], dict[str, list], int]:
|
||||
"""({「올림 이름 갈래」: 지문}, {이름: 재료 이음 표}, 건너뛴 수)."""
|
||||
out, table, skipped = {}, {}, 0
|
||||
with hold_m01(), personal():
|
||||
for tag, path in sources().items():
|
||||
name = tag.split(":", 1)[1]
|
||||
if not tag.startswith("엑셀:") or (not full and name not in QUICK_UPLOAD):
|
||||
continue
|
||||
if not path or not path.exists():
|
||||
skipped += 1
|
||||
continue
|
||||
got = upload(tag, path)
|
||||
for part, body in got.items():
|
||||
out[f"올림 {name} {part}"] = digest(body)
|
||||
table[name] = got.get("재료") or []
|
||||
return out, table, skipped
|
||||
|
||||
|
||||
def mat_counts(table: dict[str, list]) -> dict[str, dict[str, int]]:
|
||||
"""재료 이음 전후 표(`m857_mat` 꼴) — 같음(이음) · 같음(못 이음) · 생김 · 풂 · 다른 품목."""
|
||||
out = {}
|
||||
for name, rows in table.items():
|
||||
c: dict[str, int] = {}
|
||||
for r in rows:
|
||||
a, b = r[3], r[4]
|
||||
if a == b:
|
||||
k = "같음(이음)" if a else "같음(못 이음)"
|
||||
else:
|
||||
k = "풀림" if a and not b else "생김" if b and not a else "다른 품목"
|
||||
c[k] = c.get(k, 0) + 1
|
||||
out[name] = c
|
||||
return out
|
||||
@@ -0,0 +1,70 @@
|
||||
"""857-0 지킴 — 불러오기 지문(걸음 4 동안 「다름 0」 자 · 도우미 `helper_857_import`).
|
||||
|
||||
- 블록 = 원파일 EST · STC · 실무 엑셀 블록마다 엑셀 판 · 우리 판 문서 셈(노 · 재 · 경 · 계) ·
|
||||
검산 판정 · 줄 이음 판정.
|
||||
- 올림 = 실무 엑셀을 임시 개인 층에 올림 → 거절 | 호표 목록 · 칠 · 고정 줄 · 재료 이음 표.
|
||||
- 재료 이음 전후 표 = 호표 길 키 대 단가산출 길 키 갈래 수(857-4 의 기준).
|
||||
- 기본 = 빠른 표본(`QUICK_*`) · 전수 = 환경 `S857_ALL=1` · 견본 없는 PC = 그 갈래 건너뜀(수를 글로).
|
||||
- 다르면 실패 + 갈래 이름 — 뜻대로 바꾼 걸음만 다시 뜸(바뀐 갈래를 커밋 글에):
|
||||
`S857_ALL=1 ./venv/Scripts/python.exe resources/tester/test_857_import_golden.py --write`
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import warnings
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
import helper_857_import as h # noqa: E402
|
||||
|
||||
FILE = HERE / "golden_857_import.json"
|
||||
REDO = "S857_ALL=1 ./venv/Scripts/python.exe resources/tester/test_857_import_golden.py --write"
|
||||
ALL = os.environ.get("S857_ALL") == "1"
|
||||
|
||||
|
||||
def _want() -> dict:
|
||||
return json.loads(FILE.read_text("utf-8"))
|
||||
|
||||
|
||||
def _compare(got: dict[str, str], want: dict[str, str], skipped: int) -> None:
|
||||
if not got:
|
||||
pytest.skip(f"견본 없음 — 건너뜀 {skipped}")
|
||||
missing = sorted(k for k in got if k not in want)
|
||||
changed = sorted(k for k in got if k in want and want[k] != got[k])
|
||||
gone = sorted(k for k in want if k not in got) if ALL and not skipped else []
|
||||
assert not (missing or changed or gone), (
|
||||
f"지문 다름 — 바뀜 {len(changed)} {changed[:15]} · 새 {missing[:10]} · 빠짐 {gone[:10]}"
|
||||
f" · 건너뜀 {skipped}\n뜻대로 바꾼 걸음이면 다시 뜸: {REDO}"
|
||||
)
|
||||
if skipped:
|
||||
warnings.warn(f"견본 없어 건너뜀 {skipped}", stacklevel=2)
|
||||
|
||||
|
||||
def test_블록_두_판_검산_이음_지문_같음():
|
||||
got, skipped = h.blocks(ALL)
|
||||
_compare(got, _want()["블록"], skipped)
|
||||
|
||||
|
||||
def test_엑셀_올림_호표_목록_칠_고정_재료_지문_같음():
|
||||
got, table, skipped = h.uploads(ALL)
|
||||
_compare(got, _want()["올림"], skipped)
|
||||
want = _want()["재료표"]
|
||||
assert {k: v for k, v in h.mat_counts(table).items()} == {k: want[k] for k in table}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if "--write" not in sys.argv or not ALL:
|
||||
sys.exit(f"다시 뜨기 = {REDO}")
|
||||
blocks, skip_b = h.blocks(True)
|
||||
ups, table, skip_u = h.uploads(True)
|
||||
body = {"판": 1, "블록": blocks, "올림": ups, "재료표": h.mat_counts(table)}
|
||||
FILE.write_text(
|
||||
json.dumps(body, ensure_ascii=False, indent=1, sort_keys=True) + "\n", "utf-8", newline="\n"
|
||||
)
|
||||
print(f"블록 {len(blocks)} · 올림 {len(ups)} · 건너뜀 {skip_b + skip_u} → {FILE.name}")
|
||||
@@ -0,0 +1,469 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""858 5-0 층 서고 지킴 — 서버 길 답 지문 · 동시 쓰기(임시 storage · 제품 코드 안 고침).
|
||||
|
||||
① 지문 — 견본 층(단가산출 · 일위대가 · 구조물 조합 항목 · 내 기계 · 내 재료 · 공유 요청)에서
|
||||
목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한 길을
|
||||
차례로 불러 답(상태 + 몸)을 갈래마다 지문으로 → `fixtures/m02_858_shelf_golden.json` 과 같음.
|
||||
다르면 갈래 이름 + 지금 답 + 다시 뜨는 법으로 실패(건너뛰지 않음). 다시 뜸 =
|
||||
`SHELF_858_WRITE=1 ./venv/Scripts/python.exe -m pytest resources/tester/test_858_shelf_golden.py`
|
||||
(뜻한 바뀜일 때만 · 커밋 글에 까닭). 답 통째 전후 대조 = `SHELF_858_DUMP=tmp/<파일>.json`.
|
||||
② 동시 쓰기 — 잠금 없는 나무 고침 · 나무 지우기 · 합치기를 같은 판으로 겹쳐 부름. 지금 사실을
|
||||
그대로 단언(나무 = 둘 다 됨 · 뒤 것이 이김 · 지우기 + 합치기 = 앞 것이 이기고 뒤 것은 터짐) —
|
||||
「5-4 에서 뒤집을 단언」 표시 줄은 5-4 가 바꿈.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
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
|
||||
from M02_MasterTemplete import M02_Library_Same_Router as same_router
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Router_Items as items_router
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Router_Layers as layers_router
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MyMachine_Look as look_router
|
||||
from M02_MasterTemplete import M02_MyMachine_Router as machine_router
|
||||
from M02_MasterTemplete import M02_Precombo_Folders as pre_folders
|
||||
from M02_MasterTemplete import M02_Share_Request as share
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
GOLD = Path(__file__).resolve().parent / "fixtures" / "m02_858_shelf_golden.json"
|
||||
WRITE = "SHELF_858_WRITE"
|
||||
USER = {"user_id": 42, "company_id": 7, "role": "USER", "is_master": False, "name": "갑"}
|
||||
NEIGHBOR = {**USER, "user_id": 43, "name": "을"} # 같은 회사 남
|
||||
ADMIN = {**USER, "user_id": 50, "role": "ADMIN", "name": "관리"} # 회사 7 관리자
|
||||
SYSADMIN = {**USER, "user_id": 1, "role": "SYSTEM_ADMIN", "name": "시스템"}
|
||||
STRANGER = {"user_id": 90, "company_id": 9, "role": "ADMIN", "is_master": False, "name": "남"}
|
||||
MEMBERS = {42: 7, 43: 7, 44: 7, 50: 7, 1: 7, 90: 9}
|
||||
P = "/api/m02/layers/personal"
|
||||
MASK = {"날짜", "때", "처리날짜", "수정일", "넣은날", "고친날"} # 실행마다 다른 시각
|
||||
PREFIX = {"sangeun": "SK", "precombo": "SC"}
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def shelf(world, monkeypatch, tmp_path):
|
||||
async def member(owner: str) -> bool:
|
||||
company, _, user = owner.partition("/")
|
||||
return MEMBERS.get(int(user)) == int(company) if user else int(company) in (7, 9)
|
||||
|
||||
async def note(session: dict[str, Any], got: Any) -> None:
|
||||
return None
|
||||
|
||||
monkeypatch.setattr(items_router, "_member", member)
|
||||
monkeypatch.setattr(items_router, "_note", note)
|
||||
app = FastAPI()
|
||||
for one in (
|
||||
layers_router,
|
||||
items_router,
|
||||
labor_router,
|
||||
same_router,
|
||||
machine_router,
|
||||
look_router,
|
||||
share,
|
||||
):
|
||||
app.include_router(one.router)
|
||||
session = dict(USER)
|
||||
app.dependency_overrides[verify_session] = lambda: session
|
||||
return Shelf(TestClient(app), session, str(tmp_path))
|
||||
|
||||
|
||||
class Shelf:
|
||||
"""길을 부르고 답을 갈래마다 모음 — 갈래 = 「종류.일」."""
|
||||
|
||||
def __init__(self, client: TestClient, session: dict[str, Any], tmp: str):
|
||||
self.client, self.session, self.tmp = client, session, tmp
|
||||
self.got: dict[str, list[Any]] = {}
|
||||
self.seq: dict[str, dict[str, str]] = {} # 갈래마다 값 → 차례 표
|
||||
self.home: dict[str, str] = {} # 값 → 처음 본 갈래 표(길 글자용)
|
||||
|
||||
def who(self, person: dict[str, Any]) -> None:
|
||||
self.session.clear()
|
||||
self.session.update(person)
|
||||
|
||||
def go(self, branch: str, method: str, url: str, body: Any = None) -> Any:
|
||||
res = self.client.request(method, url, json=body)
|
||||
try:
|
||||
out = res.json()
|
||||
except ValueError:
|
||||
out = res.text
|
||||
who = self.session.get("user_id")
|
||||
local = self.seq.setdefault(branch, {})
|
||||
for raw, mark in self.home.items(): # 길 글자 속 uuid · 판도 같은 표로
|
||||
url = url.replace(raw, local.get(raw) or mark)
|
||||
row = [who, method, url, res.status_code, self.clean(out, branch)]
|
||||
self.got.setdefault(branch, []).append(row)
|
||||
return out
|
||||
|
||||
def clean(self, value: Any, branch: str) -> Any:
|
||||
"""실행마다 다른 것만 가림 — 임시 폴더 · 시각 · uuid 와 판(갈래 안 처음 본 차례 번호 — 같은
|
||||
값은 같은 번호라 「409 판 = 앞서 받은 판」 같은 이음은 그대로 잼 · 한 갈래가 바뀌어도 다른
|
||||
갈래 번호는 안 밀림)."""
|
||||
local = self.seq.setdefault(branch, {})
|
||||
if isinstance(value, dict):
|
||||
out = {}
|
||||
for k, v in value.items():
|
||||
if (k == "id" or k.endswith("판")) and isinstance(v, str) and v:
|
||||
out[k] = local.setdefault(v, f"<{k}{len(local) + 1}>")
|
||||
self.home.setdefault(v, f"<{branch}{out[k][1:]}")
|
||||
elif k in MASK and v is not None:
|
||||
out[k] = "<가림>"
|
||||
else:
|
||||
out[k] = self.clean(v, branch)
|
||||
return out
|
||||
if isinstance(value, list):
|
||||
return [self.clean(v, branch) for v in value]
|
||||
if isinstance(value, str):
|
||||
return value.replace(self.tmp, "<tmp>").replace(self.tmp.replace("\\", "/"), "<tmp>")
|
||||
return value
|
||||
|
||||
|
||||
def _finger(answers: list[Any]) -> str:
|
||||
text = json.dumps(answers, ensure_ascii=False, sort_keys=True, default=str)
|
||||
return hashlib.sha256(text.encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
# ── 견본 ──────────────────────────────────────────────────────────────
|
||||
def _fixed(price: int, kind: str) -> dict[str, Any]:
|
||||
line = {"고정": {"이름": "운반", "단위": "식", "단가": {"경비": price}}}
|
||||
return {**line, "수량": 1 if kind == "sangeun" else {"손": 1}}
|
||||
|
||||
|
||||
def _doc(kind: str, name: str, price: int) -> dict[str, Any]:
|
||||
field = "더한줄" if kind == "sangeun" else "담은로직"
|
||||
return {"이름": f"sub4임시{name}", "단위": "m", field: [_fixed(price, kind)]}
|
||||
|
||||
|
||||
def _library(s: Shelf, world: dict[str, Any], kind: str) -> None:
|
||||
b = f"{kind}."
|
||||
lib, tree = f"{P}/library/{kind}", f"{P}/{kind}-tree"
|
||||
one = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "가", 1000)})["이름"]
|
||||
two = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "나", 2000)})["이름"]
|
||||
s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "가", 1000)}) # 같은 내용
|
||||
twin = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "가", 1000), "새로": True})["이름"]
|
||||
s.go(b + "복사", "POST", lib, {"본뜬": {"층": "personal", "주인": "7/42", "키": two}})
|
||||
s.go(
|
||||
b + "복사",
|
||||
"POST",
|
||||
lib,
|
||||
{"본뜬": {"층": "personal", "주인": "7/42", "키": f"{PREFIX[kind]}-999999"}},
|
||||
)
|
||||
spare = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "다", 3000), "새로": True})["이름"]
|
||||
s.go(b + "목록", "GET", f"{P}/templates")
|
||||
|
||||
read = s.go(b + "읽기", "GET", f"{P}/templates/{kind}/{one}")
|
||||
s.go(b + "읽기", "GET", f"{P}/templates/{kind}/{PREFIX[kind]}-999999")
|
||||
edited = {**read["문서"], "이름": "sub4임시가고침"}
|
||||
s.go(b + "고치기", "PUT", f"{P}/templates/{kind}/{one}", {"문서": edited, "판": read["판"]})
|
||||
s.go(b + "고치기", "PUT", f"{P}/templates/{kind}/{one}", {"문서": edited, "판": read["판"]})
|
||||
|
||||
판 = s.go(b + "나무", "GET", tree)["판"]
|
||||
for body in (
|
||||
{"op": "add-folder", "경로": [], "이름": "옹벽"},
|
||||
{"op": "add-folder", "경로": [], "이름": "옹벽"}, # 이미 있음
|
||||
{"op": "move", "키": one, "새경로": ["옹벽"]},
|
||||
{"op": "rename", "경로": ["옹벽"], "이름": "석축"},
|
||||
):
|
||||
got = s.go(b + "나무", "POST", tree, {**body, "판": 판})
|
||||
판 = got.get("판", 판)
|
||||
s.go(b + "나무", "POST", tree, {"op": "add-folder", "경로": [], "이름": "x", "판": "옛판"})
|
||||
|
||||
paste = {"from_layer": "personal", "대상": [{"경로": ["석축"]}], "경로": []}
|
||||
s.go(b + "붙여넣기", "POST", f"{tree}/paste", paste)
|
||||
s.go(b + "붙여넣기", "POST", f"{tree}/paste", {**paste, "대상": [{"경로": ["없음"]}]})
|
||||
|
||||
with store.at(world["personal"]): # 쓰는 곳 = 구조물 조합 열(740-1)
|
||||
ref = {"참조": {"층": "personal", "주인": "7/42", "키": two}, "수량": {"손": 2}}
|
||||
store.write("labor", f"u{kind}", "", {"열": f"u{kind}", "담은로직": [ref], "자재": []})
|
||||
s.go(b + "쓰는곳", "POST", f"{tree}/delete-check", {"대상": [{"키": two}]})
|
||||
s.go(b + "쓰는곳", "POST", f"{tree}/delete-check", {"대상": [{"경로": ["석축"]}]})
|
||||
|
||||
판 = s.go(b + "나무", "GET", tree)["판"]
|
||||
s.go(b + "지우기", "POST", tree, {"op": "delete", "대상": [{"키": two}], "판": 판})
|
||||
gone = s.go(
|
||||
b + "지우기", "POST", tree, {"op": "delete", "대상": [{"키": two}], "판": 판, "확인": True}
|
||||
)
|
||||
s.go(b + "지우기", "GET", f"{P}/templates/{kind}/{two}")
|
||||
s.go(b + "지우기", "GET", f"{P}/templates/labor/u{kind}")
|
||||
spare_판 = s.go(b + "읽기", "GET", f"{P}/templates/{kind}/{spare}")["판"]
|
||||
s.go(b + "지우기", "DELETE", f"{P}/templates/{kind}/{spare}") # 판 없음
|
||||
s.go(b + "지우기", "DELETE", f"{P}/templates/{kind}/{spare}?판={spare_판}")
|
||||
s.go(b + "지우기", "DELETE", f"{P}/templates/{kind}/{spare}?판={spare_판}")
|
||||
|
||||
record = (gone.get("알림") or {}).get("기록")
|
||||
s.go(b + "되돌림", "POST", f"{P}/{kind}-same/undo", {"키": record or "없음"})
|
||||
s.go(b + "되돌림", "GET", f"{P}/templates/labor/u{kind}")
|
||||
s.go(b + "되돌림", "POST", f"{P}/{kind}-same/undo", {"키": "없음"})
|
||||
|
||||
found = s.go(b + "중복", "GET", f"{P}/{kind}-same")
|
||||
keep = {"층": "personal", "주인": "7/42", "키": twin}
|
||||
merge = {"남김": keep, "지움": [one], "판": found["판"]}
|
||||
s.go(b + "합치기", "POST", f"{P}/{kind}-same/merge", {**merge, "판": "옛판"})
|
||||
s.go(b + "합치기", "POST", f"{P}/{kind}-same/merge", merge)
|
||||
s.go(b + "되돌림", "POST", f"{P}/{kind}-same/undo", {"키": one})
|
||||
s.go(b + "목록", "GET", f"{P}/templates")
|
||||
s.go(b + "나무", "GET", tree)
|
||||
|
||||
|
||||
def _items(s: Shelf) -> None:
|
||||
tree = f"{P}/tree"
|
||||
판 = s.go("항목.나무", "GET", tree)["판"]
|
||||
for body in (
|
||||
{"op": "add-folder", "경로": [], "이름": "배수"},
|
||||
{"op": "add-item", "경로": ["배수"], "이름": "sub4임시측구", "단위": "m"},
|
||||
{"op": "add-item", "경로": [], "이름": "sub4임시옹벽", "단위": "m"},
|
||||
{"op": "rename", "경로": ["배수"], "이름": "수로"},
|
||||
{"op": "move", "경로": ["sub4임시옹벽"], "새경로": ["수로"]},
|
||||
{"op": "add-folder", "경로": [], "이름": "수로"}, # 이미 있음
|
||||
):
|
||||
got = s.go("항목.나무", "POST", tree, {**body, "판": 판})
|
||||
판 = got.get("판", 판)
|
||||
s.go("항목.나무", "POST", tree, {"op": "add-folder", "경로": [], "이름": "x", "판": "옛판"})
|
||||
s.go("항목.목록", "GET", "/api/m02/items?layer=personal")
|
||||
s.go("항목.목록", "GET", "/api/m02/items")
|
||||
paste = {"from_layer": "personal", "대상": [{"경로": ["수로"]}], "경로": []}
|
||||
s.go("항목.붙여넣기", "POST", f"{P}/items/paste", paste)
|
||||
system = s.go("항목.목록", "GET", "/api/m02/items")
|
||||
key = system[0]["key"] if system else "없음"
|
||||
s.go("항목.복사", "POST", f"{P}/items/copy", {"from_layer": "system", "key": key})
|
||||
s.go("항목.복사", "POST", f"{P}/items/copy", {"from_layer": "system", "key": "SS-999999"})
|
||||
판 = s.go("항목.나무", "GET", tree)["판"]
|
||||
s.go("항목.지우기", "POST", tree, {"op": "delete", "경로": ["수로(1)"], "판": 판})
|
||||
s.go("항목.나무", "GET", tree)
|
||||
|
||||
|
||||
def _machines(s: Shelf) -> None:
|
||||
m = f"{P}/my-machines"
|
||||
easy = {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로"}
|
||||
easy["값"] = {"가격": 1000, "손료계수": 2000, "주연료": 0, "주연료종류": "경유"}
|
||||
made = s.go("내기계.만들기", "POST", m, {"줄": easy})
|
||||
key = made.get("줄", {}).get("키", "없음")
|
||||
s.go("내기계.목록", "GET", m)
|
||||
one = s.go("내기계.읽기", "GET", f"{m}/{key}")
|
||||
fixed = {**easy, "값": {**easy["값"], "가격": 3000}}
|
||||
s.go("내기계.고치기", "PUT", f"{m}/{key}", {"줄": fixed, "판": one.get("판")})
|
||||
s.go("내기계.고치기", "PUT", f"{m}/{key}", {"줄": fixed, "판": one.get("판")}) # 옛 판
|
||||
s.go("내기계.쓰는곳", "POST", f"{m}/{key}/impact", {"줄": fixed})
|
||||
s.go("내기계.찾기", "GET", f"{P}/my-machine-find?q=sub4")
|
||||
s.go("내기계.목록", "GET", "/api/m02/layers/company/my-machines")
|
||||
s.go("내기계.지우기", "DELETE", f"{m}/{key}")
|
||||
s.go("내기계.지우기", "GET", f"{m}/{key}")
|
||||
|
||||
|
||||
def _materials(s: Shelf) -> None:
|
||||
m = f"{P}/materials"
|
||||
bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200}
|
||||
key = s.go("내재료.만들기", "POST", m, bolt).get("키", "없음")
|
||||
s.go("내재료.만들기", "POST", m, {**bolt, "규격": "M20"})
|
||||
s.go("내재료.만들기", "POST", "/api/m02/layers/company/materials", bolt)
|
||||
s.go("내재료.목록", "GET", m)
|
||||
s.go("내재료.목록", "GET", "/api/m02/layers/company/materials")
|
||||
s.go("내재료.고치기", "PUT", f"{m}/{key}", {**bolt, "값": 1500})
|
||||
s.go("내재료.지우기", "DELETE", f"{m}/{key}")
|
||||
s.go("내재료.지우기", "DELETE", f"{m}/{key}")
|
||||
s.go("내재료.목록", "GET", m)
|
||||
|
||||
|
||||
def _share(s: Shelf) -> None:
|
||||
url = "/api/m02/share-requests"
|
||||
item = s.go("공유.요청", "GET", "/api/m02/items?layer=personal")[0]["key"]
|
||||
pre = s.go("공유.요청", "POST", f"{P}/library/precombo", {"문서": _doc("precombo", "공유", 7)})
|
||||
one = s.go("공유.요청", "POST", url, {"종류": "item", "키": item, "글": " 회사 공용 "})
|
||||
s.go("공유.요청", "POST", url, {"종류": "item", "키": item}) # 요청 중
|
||||
two = s.go("공유.요청", "POST", url, {"종류": "precombo", "키": pre["이름"]})
|
||||
s.go("공유.요청", "POST", url, {"종류": "precombo", "키": "SC-999999"})
|
||||
s.go("공유.목록", "GET", url)
|
||||
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []}) # 일반 = 403
|
||||
s.who(STRANGER)
|
||||
s.go("공유.목록", "GET", url)
|
||||
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []})
|
||||
s.who(ADMIN)
|
||||
s.go("공유.목록", "GET", url)
|
||||
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []})
|
||||
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []}) # 이미 끝남
|
||||
s.go("공유.거절", "POST", f"{url}/{two['id']}/reject", {"사유": " 겹침 "})
|
||||
s.go("공유.목록", "GET", "/api/m02/items?layer=company")
|
||||
s.who(USER)
|
||||
s.go("공유.목록", "GET", url)
|
||||
s.go("공유.봄", "POST", f"{url}/seen")
|
||||
s.go("공유.봄", "POST", f"{url}/seen")
|
||||
|
||||
|
||||
READS = { # 남의 층 읽기 길(주인 붙임)
|
||||
"목록": "/api/m02/layers/personal/templates",
|
||||
"단가산출나무": "/api/m02/layers/personal/sangeun-tree",
|
||||
"일위대가나무": "/api/m02/layers/personal/precombo-tree",
|
||||
"항목나무": "/api/m02/layers/personal/tree",
|
||||
"내기계": "/api/m02/layers/personal/my-machines",
|
||||
"내재료": "/api/m02/layers/personal/materials",
|
||||
}
|
||||
|
||||
|
||||
def _access(s: Shelf) -> None:
|
||||
people = {"일반": USER, "같은회사남": NEIGHBOR, "회사관리": ADMIN, "시스템": SYSADMIN}
|
||||
people["남의회사관리"] = STRANGER
|
||||
for n, (name, person) in enumerate(people.items()):
|
||||
s.who(person)
|
||||
for owner in ("7/42", "7/44"): # 44 = 아직 층 없음
|
||||
for what, url in READS.items():
|
||||
s.go(f"권한.{name}", "GET", f"{url}?owner={owner}")
|
||||
s.go(f"권한.{name}", "GET", "/api/m02/layers/company/sangeun-tree")
|
||||
s.go(f"권한.{name}", "GET", "/api/m02/layers/system/sangeun-tree")
|
||||
new = {"문서": _doc("sangeun", f"권한{name}", 90 + n)} # 사람마다 다른 내용
|
||||
s.go(f"권한.{name}", "POST", "/api/m02/layers/company/library/sangeun", new)
|
||||
s.go(f"권한.{name}", "POST", "/api/m02/layers/system/library/sangeun", new)
|
||||
s.go(f"권한.{name}", "POST", f"{P}/library/sangeun?owner=7/42", new)
|
||||
s.go(f"권한.{name}", "GET", f"{P}/sangeun-same?owner=7/42")
|
||||
s.who(USER)
|
||||
|
||||
|
||||
def test_서고_길_답_지문(shelf, world):
|
||||
for kind in ("sangeun", "precombo"):
|
||||
_library(shelf, world, kind)
|
||||
_items(shelf)
|
||||
_machines(shelf)
|
||||
_materials(shelf)
|
||||
_share(shelf)
|
||||
_access(shelf)
|
||||
now = {k: _finger(v) for k, v in sorted(shelf.got.items())}
|
||||
if dump := os.environ.get("SHELF_858_DUMP"): # 전후 답 통째 대조용(자기 tmp/ 에)
|
||||
Path(dump).write_text(
|
||||
json.dumps(shelf.got, ensure_ascii=False, indent=1, default=str), "utf-8"
|
||||
)
|
||||
if os.environ.get(WRITE):
|
||||
text = json.dumps({"갈래": now}, ensure_ascii=False, indent=1) + "\n"
|
||||
GOLD.write_bytes(text.encode()) # 줄 끝 LF
|
||||
was = json.loads(GOLD.read_bytes())["갈래"]
|
||||
bad = sorted(k for k in now.keys() | was.keys() if now.get(k) != was.get(k))
|
||||
if bad:
|
||||
shown = {k: shelf.got.get(k) for k in bad}
|
||||
text = json.dumps(shown, ensure_ascii=False, default=str)[:4000]
|
||||
pytest.fail(
|
||||
f"서고 길 답 지문이 다름 — 갈래 {bad}\n지금 답: {text}\n"
|
||||
f"뜻한 바뀜이면 다시 뜸: {WRITE}=1 ./venv/Scripts/python.exe -m pytest {__file__}"
|
||||
)
|
||||
|
||||
|
||||
# ── ② 동시 쓰기 — 잠금 없는 여러 파일 쓰기(설계 858 1-4 「잠금 없는 쓰기」 · 5-4 몫) ─────────
|
||||
def _two(first, second, meet: list[tuple[Any, str]], late: tuple[Any, str]):
|
||||
"""둘을 같이 돌림 — 둘 다 판 대조를 지난 뒤 `meet` 함수 앞에서 만나고, 그 뒤 `second` 쪽
|
||||
`late` 함수를 늦춤 → (먼저 답 · 나중 답 — 예외면 예외)."""
|
||||
gate = threading.Barrier(2, timeout=10)
|
||||
slow = threading.local()
|
||||
saved = [(late[0], late[1], getattr(*late))] + [(o, n, None) for o, n in meet]
|
||||
|
||||
def later(*a, _real=saved[0][2], **k):
|
||||
if getattr(slow, "on", False):
|
||||
threading.Event().wait(0.3)
|
||||
return _real(*a, **k)
|
||||
|
||||
setattr(*late, later) # 안쪽 = 늦춤 · 바깥 = 만남(같은 함수면 만난 뒤 늦춤)
|
||||
for i, (owner, name, _) in enumerate(saved[1:], 1):
|
||||
inner = getattr(owner, name)
|
||||
saved[i] = (owner, name, inner)
|
||||
|
||||
def wait(*a, _inner=inner, **k):
|
||||
gate.wait()
|
||||
return _inner(*a, **k)
|
||||
|
||||
setattr(owner, name, wait)
|
||||
|
||||
def run(fn, is_late):
|
||||
slow.on = is_late
|
||||
try:
|
||||
return fn()
|
||||
except Exception as error: # 지금 사실(터짐)도 답으로
|
||||
return error
|
||||
|
||||
try:
|
||||
with ThreadPoolExecutor(2) as pool:
|
||||
a = pool.submit(run, first, False)
|
||||
b = pool.submit(run, second, True)
|
||||
return a.result(), b.result()
|
||||
finally:
|
||||
for owner, name, real in reversed(saved):
|
||||
setattr(owner, name, real)
|
||||
|
||||
|
||||
def _sk(me: Path, name: str, price: int, again: bool = False) -> str:
|
||||
from M02_MasterTemplete import M02_Library_Ask as ask
|
||||
|
||||
with store.at(me):
|
||||
return ask.create("sangeun", _doc("sangeun", name, price), again, None)["이름"]
|
||||
|
||||
|
||||
def _edit(me: Path, body: dict[str, Any]):
|
||||
def go():
|
||||
with store.at(me):
|
||||
return pre_folders.edit(body, "sangeun", dict(USER))
|
||||
|
||||
return go
|
||||
|
||||
|
||||
def _folders(me: Path) -> list[list[str]]:
|
||||
with store.at(me):
|
||||
return pre_folders.view("sangeun")["폴더"]
|
||||
|
||||
|
||||
def test_동시_나무_고침_둘_다_됨_뒤_것이_이김(world):
|
||||
me = world["personal"]
|
||||
with store.at(me):
|
||||
판 = pre_folders.view("sangeun")["판"]
|
||||
first, second = _two(
|
||||
_edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}),
|
||||
_edit(me, {"op": "add-folder", "경로": [], "이름": "나", "판": 판}),
|
||||
[(pre_folders, "apply_many")],
|
||||
(pre_folders, "atomic_write_json"),
|
||||
)
|
||||
assert first["알림"]["경로"] == ["가"] and second["알림"]["경로"] == ["나"] # 둘 다 됨
|
||||
assert _folders(me) == [["나"]] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것이 이김(앞 「가」 사라짐)
|
||||
|
||||
|
||||
def test_동시_나무_지우기와_고침_둘_다_됨_뒤_것이_이김(world):
|
||||
me = world["personal"]
|
||||
gone = _sk(me, "지울것", 1000)
|
||||
with store.at(me):
|
||||
판 = pre_folders.view("sangeun")["판"]
|
||||
first, second = _two(
|
||||
_edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}),
|
||||
_edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}),
|
||||
[(pre_folders, "apply_many")],
|
||||
(pre_folders, "atomic_write_json"),
|
||||
)
|
||||
assert first["알림"]["경로"] == ["가"] and second["알림"]["기록"] # 둘 다 됨
|
||||
assert not (me / "sangeun" / f"{gone}.json").exists()
|
||||
assert _folders(me) == [] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것(지우기)이 이김(「가」 사라짐)
|
||||
|
||||
|
||||
def test_동시_지우기와_합치기_앞_것이_이기고_뒤_것은_터짐(world):
|
||||
me = world["personal"]
|
||||
gone = _sk(me, "겹침", 1000)
|
||||
keep = _sk(me, "겹침", 1000, again=True)
|
||||
with store.at(me):
|
||||
판 = pre_folders.view("sangeun")["판"]
|
||||
body = same_router.MergeBody(
|
||||
남김={"층": "personal", "주인": "7/42", "키": keep}, 지움=[gone], 판=판
|
||||
)
|
||||
first, second = _two(
|
||||
_edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}),
|
||||
lambda: same_router.merge(dict(USER), me, "sangeun", body),
|
||||
[(pre_folders, "apply_many"), (same_router, "_user_index")],
|
||||
(same_router, "_user_index"),
|
||||
)
|
||||
assert first["알림"]["기록"] == gone # 지우기 = 됨(기록 키 = 그 문서)
|
||||
# 5-4 에서 뒤집을 단언 — 지금은 뒤 합치기가 판 · 지문 대조를 지난 뒤 사라진 파일에서 터짐
|
||||
# (화면 = 500) · 5-4 뒤 = 409 · 파일 앞판 그대로
|
||||
assert isinstance(second, FileNotFoundError)
|
||||
assert not (me / "sangeun" / f"{gone}.json").exists()
|
||||
assert (me / "sangeun" / f"{keep}.json").is_file()
|
||||
assert [p.stem for p in (me / same_router.GONE).glob("*.json")] == [gone] # 지우기 기록만
|
||||
Reference in New Issue
Block a user