# 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`. ② 동시 쓰기 — 나무 고침 · 나무 지우기 · 합치기를 같은 판으로 겹쳐 부름. 한 잠금(`store.batch` · 5-4) 안에서 판 대조 → 앞 것만 이기고 뒤 것은 409 · 파일은 앞 것이 쓴 그대로(반쯤 써짐 없음). """ 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 = { "날짜", "때", "처리날짜", "수정일", "넣은날", "고친날", "시점", "단가시점", } # 실행마다 다른 시각 COPY = "사본" # 단가산출 로직 사본(덩이) = 만든 때 M01 줄 · 값 — M01 이 바뀌면 바뀜(서고 일 아님) 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 in ("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) or (k == COPY and isinstance(v, dict)): 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, "").replace(self.tmp.replace("\\", "/"), "") 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] # ── 견본 ────────────────────────────────────────────────────────────── # 단가산출 = 화면이 짓는 꼴(바탕 기초 + 「따로」 수식 문서 · 855 2-C1 뒤 셈 한 길) — # 금액 = 문서 고정 줄 · # 값마다 다른 기초(단위 m) — 858-G 뒤 지문이 문서를 보아도 견본 지문 그대로 BASE = dict( zip( (1000, 2000, 3000, 90, 91, 92, 93, 94), ( "GC000006", "GC000007", "GC000008", "GC000009", "GC000010", "GC000041", "GC000042", "GC000047", ), ) ) def _formula(price: int) -> dict[str, Any]: line = {"이름": "운반", "단위": "식", "비목": "경비", "수량": "1", "단가": str(price)} return {"꼴": "수식문서", "판": 1, "결과단위": "원/m", "변수": [], "식": [], "금액": [line]} def _doc(kind: str, name: str, price: int) -> dict[str, Any]: doc = {"이름": f"sub4임시{name}", "단위": "m"} if kind == "precombo": line = {"고정": {"이름": "운반", "단위": "식", "단가": {"경비": price}}, "수량": {"손": 1}} return {**doc, "담은로직": [line]} copy = {"따로": True, "문서": _formula(price), "부름": {}} return {**doc, "바탕": {"로직": BASE[price]}, "더한줄": [], "수식": copy} 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 _race(win, lose, inside: tuple[Any, str]): """`win` 을 먼저 돌려 `inside`(판 대조 뒤 · 쓰기 앞) 안에서 붙잡아 둔 사이 `lose` 를 돌림 → (win 답 · lose 답 — 예외면 예외). 잠금이 없으면 `lose` 도 옛 판으로 대조를 지나 둘 다 됨.""" entered = threading.Event() held = threading.local() real = getattr(*inside) def hold(*a, **k): if getattr(held, "on", False): entered.set() threading.Event().wait(0.3) return real(*a, **k) def run(fn, is_win): held.on = is_win try: return fn() except Exception as error: # 진 쪽 409 도 답으로 return error setattr(*inside, hold) try: with ThreadPoolExecutor(2) as pool: a = pool.submit(run, win, True) assert entered.wait(10), "앞 것이 쓰기 자리에 못 닿음" b = pool.submit(run, lose, False) return a.result(), b.result() finally: setattr(*inside, 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 _lost(answer) -> bool: return isinstance(answer, store.StoreError) and answer.status == 409 def test_동시_나무_고침_앞_것만_됨_뒤_것은_409(world): me = world["personal"] with store.at(me): 판 = pre_folders.view("sangeun")["판"] first, second = _race( _edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}), _edit(me, {"op": "add-folder", "경로": [], "이름": "나", "판": 판}), (pre_folders, "apply_many"), ) assert first["알림"]["경로"] == ["가"] and _lost(second) assert _folders(me) == [["가"]] # 앞 것만 — 뒤 「나」 는 판이 달라 안 씀 def test_동시_나무_고침과_지우기_앞_것만_됨_뒤_지우기는_409(world): me = world["personal"] gone = _sk(me, "지울것", 1000) with store.at(me): 판 = pre_folders.view("sangeun")["판"] first, second = _race( _edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}), _edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}), (pre_folders, "apply_many"), ) assert first["알림"]["경로"] == ["가"] and _lost(second) assert (me / "sangeun" / f"{gone}.json").is_file() # 지우기 = 안 됨 · 문서 그대로 assert _folders(me) == [["가"]] assert not (me / same_router.GONE).exists() or not list((me / same_router.GONE).glob("*.json")) def test_동시_지우기와_합치기_앞_것만_됨_뒤_합치기는_409(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 = _race( _edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}), lambda: same_router.merge(dict(USER), me, "sangeun", body), (pre_folders, "apply_many"), ) assert first["알림"]["기록"] == gone # 지우기 = 됨(기록 키 = 그 문서) assert _lost(second) # 뒤 합치기 = 판이 달라 409(옛 = 사라진 파일에서 터짐 · 화면 500) 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] # 지우기 기록만 def _formula_sk(base: Any, price: int, **more: Any) -> dict[str, Any]: doc = _doc("sangeun", "", price) doc = {k: v for k, v in doc.items() if k != "바탕"} | ({"바탕": base} if base else {}) return {**doc, "수식": {**doc["수식"], **more}} def test_같은_내용_지문이_수식_문서를_봄(shelf, world): """858-G — 같은 바탕 · 다른 문서 = 중복 아님 · 같은 문서(바탕 있음 · 없음) = 중복 · 합치기 → 되돌림 왕복 그대로.""" from M02_MasterTemplete import M02_Library_Same as lsame s, lib, base = shelf, f"{P}/library/sangeun", {"로직": BASE[1000]} one = _formula_sk(base, 1000) docs = { "가": one, "가2": one, "나": _formula_sk(base, 1000, 문서=_formula(5000)), # 같은 바탕 · 수식 고침 "다": _formula_sk(None, 3000), # 바탕 없음 "다2": _formula_sk(None, 3000), } keys = { name: s.go("G", "POST", lib, {"문서": {**doc, "이름": f"sub3임시{name}"}, "새로": True})[ "이름" ] for name, doc in docs.items() } found = s.go("G", "GET", f"{P}/sangeun-same") groups = sorted(sorted(r["키"] for r in g["문서"]) for g in found["묶음"]) assert groups == sorted([sorted([keys["가"], keys["가2"]]), sorted([keys["다"], keys["다2"]])]) sk = world["personal"] / "sangeun" / f"{keys['다2']}.json" before = json.loads(sk.read_bytes()) keep = {"층": "personal", "주인": "7/42", "키": keys["다"]} merge = {"남김": keep, "지움": [keys["다2"]], "판": found["판"]} got = s.go("G", "POST", f"{P}/sangeun-same/merge", merge) assert got["합침"] == [{"키": keys["다2"], "옮긴곳수": 0}] and not sk.exists() s.go("G", "POST", f"{P}/sangeun-same/undo", {"키": keys["다2"]}) assert json.loads(sk.read_bytes()) == before again = s.go("G", "GET", f"{P}/sangeun-same") assert sorted(sorted(r["키"] for r in g["문서"]) for g in again["묶음"]) == groups # 셈에 닿는 덮음 = 다름 · 따로 문서 위 옛 줄 규칙 칸 · 판 · 시점 = 같음 cover = {"기계덮음": {"EQ": {"시간당": 2}}} assert lsame.finger("sangeun", one) != lsame.finger( "sangeun", _formula_sk(base, 1000, 문서={**_formula(1000), **cover}) ) assert lsame.finger("sangeun", one) == lsame.finger( "sangeun", {**one, "입력값": {"규격": "1"}, "수식": {**one["수식"], "판": "x", "시점": "y"}} ) derived = {**one, "수식": {"부름": {}}} # 파생 — 맡긴 기계 덮음이 셈에 얹힘 assert lsame.finger("sangeun", derived) != lsame.finger( "sangeun", {**one, "수식": {"부름": {}, **cover}} )