Files
Aislo/resources/tester/test_858_shelf_golden.py
T
eomsangdonandClaude Opus 5.5 c8c061bb10 fix(858-G): 서고 같은 내용 지문이 수식 문서를 봄 — 바탕만 같고 수식을 고친 단가산출을 중복으로 안 묶음
- 까닭: 지문이 옛 칸(바탕 · 덮개 …)만 봄 → 같은 바탕 + 수식 고침 둘 = 「내용 같음」(합치면 한쪽 고침 사라짐) · 바탕 없는 수식 문서 단가산출 = 지문 없음(진짜 중복 못 찾음)
- 따로 단가산출 = 문서 셈 칸(doc_fp) · ② 기계덮음 · 끊음 · ① 위덮음 · 옛 판 부름 + 단위 · 바탕 · 환산 · 가져온 · 값 사본 새것 여부 — 옛 줄 규칙 칸 뺌(셈에 안 씀)
- 파생 단가산출(따로 아님) = 옛 지문 그대로(줄 규칙 칸이 문서를 지음) + 맡긴 기계덮음 · 맡긴값 · 끊음 · ① · 옛 판 부름 — 저장 전 새 문서와 같은 지문 유지
- 일위대가 = 참조 줄은 그 단가산출 지문을 따라감 + 수식 부름 문서 중 지금 M01 과 다른 것만 — 호표 불러오기 재사용 · 서고 golden 그대로
- 판 · 시점 · 이름표 = 지문 밖 · 화면 [중복 찾기] · [합치기] · [되돌림] 길 안 고침
- 시험: test_858_shelf_golden 에 새 시험(같은 바탕 · 다른 문서 = 안 묶임 · 같은 문서 바탕 있음 · 없음 = 묶임 · 합치기 → 되돌림 왕복 · 기계덮음 = 다름 · 옛 칸 · 판 · 시점 = 같음 · 옛 코드로는 실패) · golden 지문 다시 안 뜸
- test_735_1 견본 단가산출 = 옛 더한줄(2-C1 뒤 못 셈 · 시작 전부터 금액 5000 ≠ 11000 실패) → 따로 수식 문서(운반 3000)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 00:48:36 +09:00

549 lines
26 KiB
Python

# 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, "<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]
# ── 견본 ──────────────────────────────────────────────────────────────
# 단가산출 = 화면이 짓는 꼴(바탕 기초 + 「따로」 수식 문서 · 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}}
)