From 97b1278a936ccd4abd9f3866cd20cb4f59df943d Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 18:41:24 +0900 Subject: [PATCH] =?UTF-8?q?test(858-5-0):=20=EC=B8=B5=20=EC=84=9C=EA=B3=A0?= =?UTF-8?q?=20=EC=A7=80=ED=82=B4=20=E2=80=94=20=EC=84=9C=EB=B2=84=20?= =?UTF-8?q?=EA=B8=B8=20=EB=8B=B5=20=EC=A7=80=EB=AC=B8=20=C2=B7=20=EB=8F=99?= =?UTF-8?q?=EC=8B=9C=20=EC=93=B0=EA=B8=B0=20=EC=8B=9C=ED=97=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 test_858_shelf_golden.py — 임시 storage 견본 층(단가산출 · 일위대가 · 구조물 조합 항목 · 내 기계 · 내 재료 · 공유 요청)에서 목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한(다섯 사람 · 남의 층 403 · 404) 길 답을 갈래마다 지문 - 지문 = fixtures/m02_858_shelf_golden.json · 다르면 갈래 이름 + 지금 답 + 다시 뜨는 법(SHELF_858_WRITE=1)으로 실패 · 시각 · uuid 가림 · 판 = 갈래 안 차례 번호 - 동시 쓰기 셋 — 나무 고침 둘 · 지우기 + 고침 · 지우기 + 합치기 같은 판 · 지금 사실 단언(뒤 것이 이김 · 뒤 합치기 터짐) · 「5-4 에서 뒤집을 단언」 표시 - 제품 코드 고침 0 · 견본 = test_m02_labor_ref 의 world 재사용 Co-Authored-By: Claude Opus 5.5 --- .../tester/fixtures/m02_858_shelf_golden.json | 54 ++ resources/tester/test_858_shelf_golden.py | 469 ++++++++++++++++++ 2 files changed, 523 insertions(+) create mode 100644 resources/tester/fixtures/m02_858_shelf_golden.json create mode 100644 resources/tester/test_858_shelf_golden.py diff --git a/resources/tester/fixtures/m02_858_shelf_golden.json b/resources/tester/fixtures/m02_858_shelf_golden.json new file mode 100644 index 000000000..811c7eaee --- /dev/null +++ b/resources/tester/fixtures/m02_858_shelf_golden.json @@ -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" + } +} diff --git a/resources/tester/test_858_shelf_golden.py b/resources/tester/test_858_shelf_golden.py new file mode 100644 index 000000000..64f489d2c --- /dev/null +++ b/resources/tester/test_858_shelf_golden.py @@ -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, "").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] + + +# ── 견본 ────────────────────────────────────────────────────────────── +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] # 지우기 기록만