- 까닭: 지문이 옛 칸(바탕 · 덮개 …)만 봄 → 같은 바탕 + 수식 고침 둘 = 「내용 같음」(합치면 한쪽 고침 사라짐) · 바탕 없는 수식 문서 단가산출 = 지문 없음(진짜 중복 못 찾음) - 따로 단가산출 = 문서 셈 칸(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>
549 lines
26 KiB
Python
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}}
|
|
)
|