Merge branch 'sub_laptop_4' of C:/Aislo_wt/sub_laptop_4 into main_laptop_1

This commit is contained in:
2026-11-17 18:42:27 +09:00
2 changed files with 523 additions and 0 deletions
@@ -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"
}
}
+469
View File
@@ -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] # 지우기 기록만