From 06524d6182989b885de23e2d33478f4d7bff23a3 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 18:44:42 +0900 Subject: [PATCH 1/2] =?UTF-8?q?test(856-0):=20=EB=8B=A8=EA=B0=80=EC=82=B0?= =?UTF-8?q?=EC=B6=9C=20=ED=99=94=EB=A9=B4=20=EC=A7=80=ED=82=B4=20=E2=80=94?= =?UTF-8?q?=20=EA=B0=80=EC=A7=9C=20DOM=20=EC=8B=9C=ED=97=98(=EB=B6=80?= =?UTF-8?q?=EB=A6=84=20=EC=88=98=20=C2=B7=20=EC=88=A8=EC=9D=80=20=EB=AA=B8?= =?UTF-8?q?=20=C2=B7=20=EC=A4=84=20=EB=88=84=EB=A6=84=20=C2=B7=20=EB=A8=B8?= =?UTF-8?q?=EB=A6=AC=20=EB=9D=A0=20=C2=B7=20M01=20=EC=83=81=EC=84=B8)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 단가산출 화면 열 때 /sangeun/calc 부름 수(바탕 있음 2 · 없음 1) · 숨은 상세 몸 DOM 2 - 일위대가 줄 누름 — SK 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 = 옛 줄 모달(상세 몸) · 셈 주입 줄 - 머리 띠 넷(까닭 · M01 개정 · 빠진 줄 · 짝 잃음) 견본 답 · M01 로직 상세 그릇 꼴 - 지금 수치 그대로 단언 — 856-1 에서 뒤집음 Co-Authored-By: Claude Opus 5.5 --- resources/tester/helper_856_0_sk_screen.cjs | 415 ++++++++++++++++++++ resources/tester/test_856_0_sk_screen.py | 77 ++++ 2 files changed, 492 insertions(+) create mode 100644 resources/tester/helper_856_0_sk_screen.cjs create mode 100644 resources/tester/test_856_0_sk_screen.py diff --git a/resources/tester/helper_856_0_sk_screen.cjs b/resources/tester/helper_856_0_sk_screen.cjs new file mode 100644 index 000000000..497c2b03b --- /dev/null +++ b/resources/tester/helper_856_0_sk_screen.cjs @@ -0,0 +1,415 @@ +/* 856-0 헬퍼 — 단가산출 화면 · 일위대가 줄 누름 · 머리 띠 · M01 로직 상세(가짜 DOM · 진짜 코드) + * 진짜 = M02 단가산출 화면(`Sangeun_Detail` 과 그 이웃) · 일위대가 표(`Labor_Table`) · 줄 모달 · M01 상세 그릇 + * 가짜 = 부품 상자(표지 붙은 빈 상자) · 줄 쌓기 화면(그린 키만 적음) · 서버 부름(길 · 몸을 적고 견본 답) */ +const fs = require("fs"); +const path = require("path"); +const ROOT = path.resolve(__dirname, "..", ".."); +const ts = require(path.join(ROOT, "config", "node_modules", "typescript")); + +const camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase()); +class Fake { + constructor(tag) { + this.tagName = String(tag).toUpperCase(); + this.children = []; + this.parentElement = null; + this.dataset = {}; + this.attrs = {}; + this.style = { setProperty() {} }; + this.hidden = false; + this.className = ""; + this.textContent = ""; + this.value = ""; + this.disabled = false; + this.classList = { add() {}, remove() {}, toggle() {}, contains: () => false }; + } + append(...xs) { + for (const x of xs) + if (x instanceof Fake) { + x.parentElement = this; + this.children.push(x); + } + } + prepend(...xs) { + this.append(...xs); + } + replaceChildren(...xs) { + this.children = []; + this.append(...xs); + } + remove() {} + get firstChild() { + return this.children[0] ?? null; + } + addEventListener() {} + removeEventListener() {} + setAttribute(k, v) { + this.attrs[k] = v; + if (k.startsWith("data-")) this.dataset[camel(k.slice(5))] = v; + } + removeAttribute() {} + contains() { + return false; + } + querySelector() { + return null; + } + focus() {} +} +globalThis.window = globalThis; +globalThis.addEventListener = () => {}; +globalThis.removeEventListener = () => {}; +globalThis.getComputedStyle = () => ({ overflowY: "visible" }); +globalThis.requestAnimationFrame = (f) => setTimeout(f, 0); +globalThis.HTMLElement = Fake; +globalThis.HTMLInputElement = class extends Fake {}; +globalThis.HTMLTextAreaElement = class extends Fake {}; +globalThis.document = { + createElement: (t) => new Fake(t), + body: new Fake("body"), + activeElement: null, +}; +globalThis.sessionStorage = { getItem: () => null, setItem() {}, removeItem() {} }; + +/** 표지 붙은 빈 상자 */ +const box = (tag, mark = {}, text = "") => { + const n = new Fake(tag); + for (const [k, v] of Object.entries(mark)) n.setAttribute(k, v); + n.textContent = text; + return n; +}; +const el = (tag, o = {}) => { + const n = box(tag, o.attrs ?? {}, o.text ?? ""); + n.className = o.className ?? ""; + n.append(...(o.children ?? [])); + return n; +}; +const button = (o = {}) => box("button", { "data-button": o.label ?? "" }); +const input = (o = {}) => { + const i = box("input"); + i.value = o.value ?? ""; + return { root: box("label", { "data-input": o.label ?? "" }, ""), input: i, setError() {} }; +}; +const modals = []; // 열린 모달 — 제목 · 몸 +const ui = { + ui_template_elements: { + el, + createButton: button, + createInputField: input, + showToast() {}, + showConfirmDialog: async () => true, + }, + ui_template_button: { createButton: button }, + ui_template_input: { createInputField: input }, + ui_template_banner: { createBanner: (o) => box("div", { "data-banner": o.tone }, o.text) }, + ui_template_badge: { createBadge: (text, tone) => box("span", { "data-badge": tone }, text) }, + ui_template_text: { createText: (text) => box("span", {}, text) }, + ui_template_checkbox: { createCheckbox: () => ({ root: box("label") }) }, + ui_template_card: { createCard: () => box("div") }, + ui_template_locale: { t: (k) => k, currentLanguageIndex: 0 }, + ui_template_modal: { + openModal: (o) => { + const body = box("div", { "data-modal": o.title }); + const head = box("div"); + const close = () => {}; + o.mount?.(body, close, head); + modals.push({ title: o.title, body, head, actions: o.actions ?? [] }); + return { close }; + }, + askConfirm: async () => true, + askText: async () => null, + showConfirmDialog: async () => true, + }, + ui_template_side_panels: { + createSidePanels: () => ({ current: () => null, root: box("div"), wrap: (m) => m }), + }, + ui_template_hopyo_grid: { + hopyoGrid: (blocks) => ({ + at: new Map(blocks[0].lines.map((_, i) => [i, [0, i]])), + columns: [], + rows: [], + }), + createHopyoGrid: (_blocks, o) => ((grid.onRowClick = o.onRowClick), { root: box("table") }), + hopyoCellClass: () => "", + }, +}; +const grid = { onRowClick: null }; + +// 줄 쌓기 화면 = 그린 키 · 저장 전 문서만 적음 +const stacks = []; +const screen = { + createStackScreen: (opt) => { + const s = { root: box("div", { "data-stack": "" }), draws: [], opt }; + stacks.push(s); + return { + root: s.root, + draw: (k) => s.draws.push({ key: k, memory: !k && !!opt.memory?.() }), + dirty: () => false, + save: async () => true, + discard: async () => {}, + canLeave: async () => true, + destroy() {}, + }; + }, +}; + +// 서버 부름 — 길 · 몸을 적고 견본 답 +const calls = []; +let skAnswer = () => ({}); +const api = { + call: async (p, init) => { + calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null }); + if (p.includes("/sangeun/calc")) return skAnswer(); + if (p.includes("/labor/")) return { 줄: [], 자재: [], 알약: [] }; + return {}; + }, + readTemplate: async (_l, _k, key) => ({ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }), + saveTemplate: async () => ({}), + getActiveLayer: () => "system", + getActiveOwner: () => null, +}; +const logicApi = { + fetchLogic: async (k) => ({ + logic: { 키: k, 이름: "기초", 결과단위: "원/㎡", 입력: [] }, + prices: {}, + file: "", + reasons: [], + }), + fetchAuto: async () => ({}), + setLogicApiPaths() {}, + ApiError: class extends Error {}, +}; + +const stubs = { + ...ui, + line_stack_screen: screen, + M02_MasterTemplete_Api_Fetch: api, + M01_MasterData_UI_Logic_Api: logicApi, + M02_MasterTemplete_Sangeun_Side: { + createSangeunSide: () => ({ wrap: (m) => m, set() {} }), + tabOf: () => ({}), + }, + M01_MasterData_UI_LogicLab_Ho: { buildHo: () => [box("div", { "data-ho": "" })] }, + M02_MasterTemplete_Sangeun_Unit: { buildUnitSwap: () => null, baseUnitOf: () => "" }, + M02_MasterTemplete_Labor_LogicMats: { logicMatRows: () => [] }, + M02_Labor_Values_Model: { + valueLine: () => ({ text: "", empty: 0 }), + keepKnown: (_a, b) => ({ kept: b }), + }, + M02_MasterTemplete_Labor_Grid: { + laborBlock: (cur) => ({ lines: cur.담은로직.map(() => ({ note: "", amounts: { sum: 1 } })) }), + }, + M02_DF_UnitPick: { createUnitPick: () => box("div"), NO_UNIT: "-" }, + M02_MasterTemplete_Labor_Unlinked: { unlinkedBar: () => null }, + M02_MasterTemplete_Labor_Text: { tc: (k) => k }, + M02_MasterTemplete_Labor_LibMeta: { libMeta: () => [] }, + M02_MasterTemplete_Labor_National: { nationalRows: () => [] }, +}; +const real = new Set([ + "M02_MasterTemplete_Sangeun_Detail", + "M02_MasterTemplete_Sangeun_Tabs", + "M02_MasterTemplete_Sangeun_Cover", + "M02_MasterTemplete_Sangeun_BaseHead", + "M02_Sangeun_Cover_Model", + "M02_Sangeun_Undo", + "M02_Born_Tag", + "M01_MasterData_UI_LogicLab_Detail", + "M02_MasterTemplete_Labor_Table", + "M02_MasterTemplete_Labor_SkEdit", + "M02_MasterTemplete_Labor_RowModal", + "M02_MasterTemplete_Labor_RowSk", + "M02_MasterTemplete_Labor_Api", + "M02_MasterTemplete_Labor_Calc", +]); + +const empty = () => + new Proxy(function () {}, { + get: (_, k) => (k === "then" ? undefined : empty()), + apply: () => undefined, + }); +const cache = new Map(); +function load(at) { + if (cache.has(at)) return cache.get(at); + const js = ts.transpileModule(fs.readFileSync(at, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const mod = { exports: {} }; + cache.set(at, mod.exports); + const need = (p) => { + if (p.endsWith(".css")) return {}; + const name = path.basename(p); + if (stubs[name]) return stubs[name]; + if (p.startsWith("@config/")) return { API_BASE_URL: "" }; + if (!p.startsWith(".")) return empty(); + const r = `${path.resolve(path.dirname(at), p)}.ts`; + return real.has(path.basename(r, ".ts")) && fs.existsSync(r) ? load(r) : empty(); + }; + new Function("exports", "module", "require", js)(mod.exports, mod, need); + return mod.exports; +} +const M = (rel) => load(path.join(ROOT, rel)); +const tick = () => new Promise((r) => setTimeout(r, 0)); +const settle = async () => { + for (let i = 0; i < 20; i++) await tick(); +}; +const walk = (n, fn) => { + fn(n); + for (const c of n.children) walk(c, fn); +}; +const all = (root, pred) => { + const out = []; + walk(root, (n) => pred(n) && out.push(n)); + return out; +}; +/** 숨은 조상까지 보고 보이는가 */ +const shown = (n) => { + for (let x = n; x; x = x.parentElement) if (x.hidden) return false; + return true; +}; +const skCalls = () => calls.filter((c) => c.path.includes("/sangeun/calc")); +const plainAns = (o = {}) => ({ + 기준: null, + 줄: [ + { 이름: "보통인부", cid: "labor:LB1#0", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } }, + ], + 정체: ["labor:LB1#0"], + 짝잃음: [], + 빠진줄: [], + 바탕판: "v1", + ...o, +}); + +/** 단가산출 화면 한 벌 열기 — 부름 수 · 숨은 몸 · 줄 쌓기 그림 · 띠 */ +async function openSk(doc, opt = {}) { + calls.length = 0; + stacks.length = 0; + const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts"); + const host = box("div"); + const h = mountSangeunDetail(host, doc, { + layer: "system", + owner: null, + readOnly: false, + onChanged() {}, + ...opt, + }); + await settle(); + const s = stacks[stacks.length - 1]; + const r = { + calc: skCalls().length, + body: all(host, (n) => "skCover" in n.dataset || "ho" in n.dataset).length, // 몸 DOM(덮개 그릇 · 호표) + bodyShown: all(host, (n) => "skCover" in n.dataset && shown(n)).length, + stack: s ? { shown: shown(s.root), draws: s.draws } : null, + banners: all(host, (n) => "banner" in n.dataset).map((n) => n.dataset.banner), + badges: all(host, (n) => "badge" in n.dataset).map((n) => [n.dataset.badge, n.textContent]), + }; + h.destroy(); + return r; +} + +(async () => { + const out = {}; + skAnswer = () => plainAns(); + // ① 단가산출 화면(페이지) — 바탕 있음 · 없음 + out.page_base = await openSk( + { 키: "SK-000001", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } }, + { source: true }, + ); + out.page_nobase = await openSk({ 키: "SK-000002", 이름: "견본", 단위: "㎡" }, { source: true }); + // 불러오기 미리 보기(저장 전 가져온 식) + out.memory = await openSk({ 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } }); + + // ③ 머리 띠 넷(견본 답) — 까닭 · M01 개정 · 빠진 줄 · 짝 잃음 + 머리 배지 + skAnswer = () => + plainAns({ + 까닭: "못 셈", + 빠진줄: [{ cid: "labor:LB2#1", 이름: "특별인부", 까닭: "입력 없음" }], + 짝잃음: [{ cid: "labor:LB9#0", 까닭: "줄 없음" }], + 바탕판: "v2", + 머리: "계", + }); + out.bands = await openSk( + { 키: "SK-000003", 이름: "띠", 단위: "㎡", 바탕: { 로직: "GC001109" }, 바탕판: "v1" }, + { source: true }, + ); + skAnswer = () => { + throw new Error("서버 못 닿음"); + }; + out.bands_fail = await openSk({ 키: "SK-000004", 이름: "띠", 단위: "㎡" }, { source: true }); + skAnswer = () => plainAns(); + + // ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄 + const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts"); + const rows = [ + { + 참조: { 층: "system", 주인: null, 키: "SK-000010" }, + 별칭: null, + 메모: null, + 수량: { 손: 1 }, + }, + { 로직: "GC001109", 별칭: null, 메모: null, 입력값: {}, 수량: { 손: 1 } }, + ]; + const click = async (calc) => { + const res = []; + for (let i = 0; i < rows.length; i++) { + const t = mountLaborTable( + box("div"), + { 담은로직: JSON.parse(JSON.stringify(rows)), 자재: [], 단위: "㎡" }, + { + mode: "precombo", + layer: "system", + column: "공통", + readOnly: false, + owner: null, + onChanged() {}, + ...(calc ? { calc: async () => ({ 줄: [], 자재: [] }) } : {}), + }, + ); + await settle(); + modals.length = 0; + stacks.length = 0; + calls.length = 0; + grid.onRowClick(i); + await settle(); + const m = modals[0]; + const s = stacks[0]; + res.push({ + modal: m ? m.title : null, + skModal: m ? all(m.body, (n) => "laborSk" in n.dataset).length : 0, // 그 SK 문서 모달(806-1) + stack: s ? { shown: shown(s.root), draws: s.draws.map((d) => d.key) } : null, + body: m ? all(m.body, (n) => "skCover" in n.dataset && shown(n)).length : 0, + banners: m ? all(m.body, (n) => "banner" in n.dataset).map((n) => n.dataset.banner) : [], + calc: skCalls().length, + }); + t.destroy?.(); + } + return res; + }; + out.labor = await click(false); + out.labor_inject = await click(true); + + // ④ M01 로직 상세 그릇 — 기본정보 접힘 + 줄 쌓기 + const { buildLabDetail } = M("M01_MasterData/M01_MasterData_UI_LogicLab_Detail.ts"); + const host = box("div"); + const stack = box("div", { "data-stack": "" }); + buildLabDetail(host, { + row: { + 키: "GC001109", + 원문번호: "1-1", + 이름: "기초", + 결과단위: "원/㎡", + 입력: [], + 중간: [], + 호표: [], + 덧줄: [], + }, + file: "f.json", + reasons: ["막힘"], + ownHost: box("div"), + onChange() {}, + stack, + }); + out.m01 = host.children.map((n) => n.tagName + (n.dataset.stack !== undefined ? ":stack" : "")); + console.log(JSON.stringify(out)); +})().catch((e) => { + console.error(e.stack || String(e)); + process.exit(1); +}); diff --git a/resources/tester/test_856_0_sk_screen.py b/resources/tester/test_856_0_sk_screen.py new file mode 100644 index 000000000..cd171acee --- /dev/null +++ b/resources/tester/test_856_0_sk_screen.py @@ -0,0 +1,77 @@ +# -*- coding: utf-8 -*- +"""PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`). + +① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 수 · 숨은 상세 몸 DOM · 줄 쌓기 그림 +② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄 +③ 머리 띠 넷(까닭 · M01 개정 · 빠진 줄 · 짝 잃음)이 뜨는 경우 — 견본 답 +④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기 +""" + +from __future__ import annotations + +import json +import os +import subprocess +from functools import lru_cache + +HERE = os.path.dirname(os.path.abspath(__file__)) + + +@lru_cache(maxsize=1) +def _run() -> dict: + proc = subprocess.run( + ["node", os.path.join(HERE, "helper_856_0_sk_screen.cjs")], + capture_output=True, + text=True, + encoding="utf-8", + ) + assert proc.returncode == 0, proc.stderr[-3000:] + return json.loads(proc.stdout) + + +def test_sk_page_open_calls_and_hidden_body() -> None: + got = _run() + # 바탕 있는 SK = 셈 두 번(바탕 원값 bare) · 바탕 없음 = 한 번 · 상세 몸 DOM 둘(덮개 그릇 · 호표) 숨김 + assert got["page_base"]["calc"] == 2 + assert got["page_nobase"]["calc"] == 1 + for k in ("page_base", "page_nobase", "memory"): + assert got[k]["body"] == 2, k + assert got[k]["bodyShown"] == 0, k + assert got[k]["stack"]["shown"] is True, k + assert {d["key"] for d in got["page_base"]["stack"]["draws"]} == {"SK-000001"} + # 불러오기 미리 보기(저장 전 가져온 식) = 빈 키 + 문서째 + assert all(d == {"key": "", "memory": True} for d in got["memory"]["stack"]["draws"]) + assert got["memory"]["calc"] == 1 + + +def test_labor_row_click() -> None: + sk, logic = _run()["labor"] + # 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 · 몸 안 보임 + assert sk["skModal"] == 1 and sk["stack"]["shown"] is True + assert set(sk["stack"]["draws"]) == {"SK-000010"} and sk["body"] == 0 + # M01 로직 줄 = 옛 줄 모달 — 줄 쌓기 숨김 · 상세 몸 보임 · 안내 띠 하나 · 셈 둘(정체 + 상세) + assert logic["skModal"] == 0 and logic["stack"]["shown"] is False + assert logic["body"] == 1 and logic["banners"] == ["info"] and logic["calc"] == 2 + + +def test_labor_row_click_inject() -> None: + sk, logic = _run()["labor_inject"] + # 셈 주입(프로젝트 사본) = 옛 줄 모달 · 상세 없음 · 안내 띠 없음 · 셈 없음 + for row in (sk, logic): + assert row["modal"] and row["stack"] is None + assert row["body"] == 0 and row["banners"] == [] and row["calc"] == 0 + + +def test_head_bands_four() -> None: + got = _run() + # 까닭(빨강) · M01 개정 · 빠진 줄 · 짝 잃음(노랑) + 머리 배지 · 개정 배지 + assert got["bands"]["banners"] == ["danger", "warning", "warning", "warning"] + assert got["bands"]["badges"] == [["info", "계"], ["danger", "M02_SangeunRevisedBase"]] + # 서버 못 닿음 = 빨강 하나 + assert got["bands_fail"]["banners"] == ["danger"] + assert got["page_base"]["banners"] == [] and got["page_base"]["badges"] == [] + + +def test_m01_logic_detail_shape() -> None: + # 기본정보 접힘 · 막힘 까닭 · 줄 쌓기 — 단가산출 상세 몸 칸 없음 + assert _run()["m01"] == ["DETAILS", "DIV", "DIV:stack"] From 39e0a72931e8145effcff216fa2a59aec2c14a0c Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 20:46:11 +0900 Subject: [PATCH 2/2] =?UTF-8?q?refactor(5-4):=20=EC=97=AC=EB=9F=AC=20?= =?UTF-8?q?=ED=8C=8C=EC=9D=BC=20=EC=93=B0=EA=B8=B0=20=ED=95=9C=20=EC=9E=A0?= =?UTF-8?q?=EA=B8=88=20=E2=80=94=20Store.batch(=EB=8B=A4=EC=8B=9C=20?= =?UTF-8?q?=EB=93=A4=EC=96=B4=EA=B0=80=EB=8A=94=20=EC=9E=A0=EA=B8=88)=20?= =?UTF-8?q?=C2=B7=20=EB=82=98=EB=AC=B4=20=EA=B3=A0=EC=B9=A8=20=C2=B7=20?= =?UTF-8?q?=ED=95=A9=EC=B9=98=EA=B8=B0=20=C2=B7=20=EB=90=98=EB=8F=8C?= =?UTF-8?q?=EB=A6=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Store._LOCK = RLock · Store.batch() = 판 대조부터 마지막 쓰기까지 한 잠금(안에서 Store.write 불러도 됨) - Precombo_Folders.edit(지우기 Library_Delete.remove 포함) · Library_Same_Router.merge · undo(Library_Delete.undo 포함)를 batch 안에서 - merge 판 대조를 「없는 문서」 검사 앞으로 — 지우기와 겹쳐 진 합치기 = 409(옛 = 사라진 파일에서 터짐 · 화면 500) - 늦은 쓰기(_refresh_labor 류) · write_template(5-3) · 권한(5-1) 그대로 · San_MatPick.write(sub8) 안 고침 · remove 되돌림 몸 이동은 5-8 - test_858_shelf_golden 동시 쓰기 셋 뒤집음: 앞 것만 됨 · 뒤 것 409 · 파일 앞판 그대로 — 겹침 꼴을 _race 로(앞 것을 쓰기 자리에서 붙잡음 · 잠금을 빼면 셋 다 실패) · 지문 50 갈래 그대로 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Library_Delete.py | 3 +- M02_MasterTemplete/M02_Library_Same_Router.py | 23 +++-- .../M02_MasterTemplete_Store.py | 10 +- M02_MasterTemplete/M02_Precombo_Folders.py | 8 +- resources/tester/test_858_shelf_golden.py | 92 +++++++++---------- 5 files changed, 75 insertions(+), 61 deletions(-) diff --git a/M02_MasterTemplete/M02_Library_Delete.py b/M02_MasterTemplete/M02_Library_Delete.py index 4e8a678b3..47c2f7ccf 100644 --- a/M02_MasterTemplete/M02_Library_Delete.py +++ b/M02_MasterTemplete/M02_Library_Delete.py @@ -178,7 +178,8 @@ def remove( at = refs.folder_of(r["층"], r["주인"]) / r["문서종류"] / f"{r['문서']}.json" files[at] = r done: list[dict[str, Any]] = [] - # ponytail: 여러 파일을 차례로 씀(잠금 없음) — 실패하면 앞서 고친 파일을 앞판 바이트로 되돌림 + # ponytail: 부르는 곳(`Precombo_Folders.edit`)의 `store.batch` 안 — 실패하면 앞서 고친 파일을 + # 앞판 바이트로 되돌림(되돌림 몸을 `batch` 로 옮기는 것은 5-8) for path, r in files.items(): raw = path.read_bytes() try: diff --git a/M02_MasterTemplete/M02_Library_Same_Router.py b/M02_MasterTemplete/M02_Library_Same_Router.py index 362261e12..36dafde1f 100644 --- a/M02_MasterTemplete/M02_Library_Same_Router.py +++ b/M02_MasterTemplete/M02_Library_Same_Router.py @@ -205,6 +205,12 @@ def find(folder: Path, kind: str) -> dict[str, Any]: # ── 합치기 ──────────────────────────────────────────────────────────── def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[str, Any]: + """판 대조부터 마지막 쓰기까지 `store.batch` — 같은 층 지우기 · 나무 고침과 겹치면 진 쪽 409.""" + with store.batch(): + return _merge(session, folder, kind, body) + + +def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[str, Any]: mine = refs.where(folder) raw = body.남김 or {} keep_at: refs.Here = (str(raw.get("층") or ""), raw.get("주인") or None) @@ -216,13 +222,13 @@ def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[st gone = list(dict.fromkeys(str(k) for k in body.지움)) if not gone or (keep_at == mine and keep["키"] in gone): raise _bad(400, "지울 문서를 고름 — 남김과 달라야 함") + with store.at(folder): + tree_doc, 판 = pre_folders._read(kind) + if 판 != body.판: # 없는 문서 검사 앞 — 겹쳐 진 쪽(그새 지워짐)은 409 + raise _bad(409, {"stale": [pre_folders.file_of(kind)], "판": 판}) have = dict(_docs(mine, kind)) if miss := [k for k in gone if k not in have]: raise _bad(404, f"이 층에 없는 문서 「{' · '.join(miss)}」") - with store.at(folder): - tree_doc, 판 = pre_folders._read(kind) - if 판 != body.판: - raise _bad(409, {"stale": [pre_folders.file_of(kind)], "판": 판}) marks = same.Same() mark = marks.finger(kind, keep_doc) if mark is None or any(marks.finger(kind, have[k]) != mark for k in gone): @@ -259,7 +265,6 @@ def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[st places = dict(tree_doc.get("자리") or {}) done, kept = [], [] when = datetime.now().isoformat(timespec="seconds") - # ponytail: 여러 파일을 차례로 씀(잠금 없음) — 동시에 같은 층을 합치면 앞 것이 이김 for key in gone: if left[key]: kept.append({"키": key, "쓰는곳": left[key]}) @@ -284,7 +289,13 @@ def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[st def undo(session: Session, folder: Path, kind: str, key: str) -> dict[str, Any]: - """`_합친것/<키>` 되돌림 — 문서 · 나무 자리 · 옮긴 참조(아직 남김을 가리키고 쓸 수 있는 곳).""" + """`_합친것/<키>` 되돌림 — 문서 · 나무 자리 · 옮긴 참조(아직 남김을 가리키고 쓸 수 있는 곳) · + 한 `store.batch`(지움 기록 되돌림 `M02_Library_Delete.undo` 도 이 안).""" + with store.batch(): + return _undo(session, folder, kind, key) + + +def _undo(session: Session, folder: Path, kind: str, key: str) -> dict[str, Any]: mine = refs.where(folder) rec_path = folder / GONE / f"{key}.json" try: diff --git a/M02_MasterTemplete/M02_MasterTemplete_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Store.py index aa1f42a59..e80ba2f86 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Store.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Store.py @@ -76,8 +76,14 @@ _BAD_NAME = re.compile(r'[\\/:*?"<>|\x00-\x1f]|\.\.') # of undefined (reading 'length')") · CAD 쪽도 없으면 새로 채우지만(2026-09-27 sub1 고침) # 뿌리도 처음부터 채움 _BLANK_LAYER = {"id": "기본", "name": "기본", "isVisible": True, "isLocked": False} -# ponytail: 저장은 한 번에 하나(프로세스 안 잠금) · 서버를 여럿 띄우면 파일 잠금으로 -_LOCK = threading.Lock() +# ponytail: 저장은 한 번에 하나(프로세스 안 잠금 · 다시 들어감) · 서버를 여럿 띄우면 파일 잠금으로 +_LOCK = threading.RLock() + + +def batch() -> threading.RLock: + """여러 파일 쓰기 한 묶음(858 5-4) — 판 대조부터 마지막 쓰기까지 한 잠금 · 안에서 `write` · + `delete` 를 불러도 됨(다시 들어가는 잠금) · 겹친 쪽은 잠금 뒤 판 대조에서 409.""" + return _LOCK class StoreError(Exception): diff --git a/M02_MasterTemplete/M02_Precombo_Folders.py b/M02_MasterTemplete/M02_Precombo_Folders.py index b7bb98c53..92ec85a11 100644 --- a/M02_MasterTemplete/M02_Precombo_Folders.py +++ b/M02_MasterTemplete/M02_Precombo_Folders.py @@ -181,7 +181,13 @@ def edit( body: dict[str, Any], kind: str = "precombo", session: dict[str, Any] | None = None ) -> dict[str, Any]: """지금 층 자리 파일을 고쳐 씀(지우기면 문서 파일째 · 쓰는 곳 = `deleting.remove` · 몸 `확인`) → - 새 나무 + 알림(지우기 = `기록` 되돌림 키) · 판 다르면 409.""" + 새 나무 + 알림(지우기 = `기록` 되돌림 키) · 판 다르면 409 · 판 대조부터 쓰기까지 + `store.batch`.""" + with store.batch(): + return _edit(body, kind, session) + + +def _edit(body: dict[str, Any], kind: str, session: dict[str, Any] | None) -> dict[str, Any]: doc, 판 = _read(kind) if 판 != str(body.get("판") or ""): raise store.StoreError(409, {"stale": [file_of(kind)], "판": 판}) diff --git a/resources/tester/test_858_shelf_golden.py b/resources/tester/test_858_shelf_golden.py index 64f489d2c..d1ff49a0e 100644 --- a/resources/tester/test_858_shelf_golden.py +++ b/resources/tester/test_858_shelf_golden.py @@ -7,9 +7,8 @@ 다르면 갈래 이름 + 지금 답 + 다시 뜨는 법으로 실패(건너뛰지 않음). 다시 뜸 = `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 가 바꿈. +② 동시 쓰기 — 나무 고침 · 나무 지우기 · 합치기를 같은 판으로 겹쳐 부름. 한 잠금(`store.batch` · + 5-4) 안에서 판 대조 → 앞 것만 이기고 뒤 것은 409 · 파일은 앞 것이 쓴 그대로(반쯤 써짐 없음). """ from __future__ import annotations @@ -354,45 +353,36 @@ def test_서고_길_답_지문(shelf, world): ) -# ── ② 동시 쓰기 — 잠금 없는 여러 파일 쓰기(설계 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] +# ── ② 동시 쓰기 — 여러 파일 쓰기 한 잠금(설계 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 later(*a, _real=saved[0][2], **k): - if getattr(slow, "on", False): + def hold(*a, **k): + if getattr(held, "on", False): + entered.set() threading.Event().wait(0.3) - return _real(*a, **k) + 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 + def run(fn, is_win): + held.on = is_win try: return fn() - except Exception as error: # 지금 사실(터짐)도 답으로 + except Exception as error: # 진 쪽 409 도 답으로 return error + setattr(*inside, hold) try: with ThreadPoolExecutor(2) as pool: - a = pool.submit(run, first, False) - b = pool.submit(run, second, True) + a = pool.submit(run, win, True) + assert entered.wait(10), "앞 것이 쓰기 자리에 못 닿음" + b = pool.submit(run, lose, False) return a.result(), b.result() finally: - for owner, name, real in reversed(saved): - setattr(owner, name, real) + setattr(*inside, real) def _sk(me: Path, name: str, price: int, again: bool = False) -> str: @@ -415,37 +405,40 @@ def _folders(me: Path) -> list[list[str]]: return pre_folders.view("sangeun")["폴더"] -def test_동시_나무_고침_둘_다_됨_뒤_것이_이김(world): +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 = _two( + first, second = _race( _edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}), _edit(me, {"op": "add-folder", "경로": [], "이름": "나", "판": 판}), - [(pre_folders, "apply_many")], - (pre_folders, "atomic_write_json"), + (pre_folders, "apply_many"), ) - assert first["알림"]["경로"] == ["가"] and second["알림"]["경로"] == ["나"] # 둘 다 됨 - assert _folders(me) == [["나"]] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것이 이김(앞 「가」 사라짐) + assert first["알림"]["경로"] == ["가"] and _lost(second) + assert _folders(me) == [["가"]] # 앞 것만 — 뒤 「나」 는 판이 달라 안 씀 -def test_동시_나무_지우기와_고침_둘_다_됨_뒤_것이_이김(world): +def test_동시_나무_고침과_지우기_앞_것만_됨_뒤_지우기는_409(world): me = world["personal"] gone = _sk(me, "지울것", 1000) with store.at(me): 판 = pre_folders.view("sangeun")["판"] - first, second = _two( + first, second = _race( _edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}), _edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}), - [(pre_folders, "apply_many")], - (pre_folders, "atomic_write_json"), + (pre_folders, "apply_many"), ) - assert first["알림"]["경로"] == ["가"] and second["알림"]["기록"] # 둘 다 됨 - assert not (me / "sangeun" / f"{gone}.json").exists() - assert _folders(me) == [] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것(지우기)이 이김(「가」 사라짐) + 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_동시_지우기와_합치기_앞_것이_이기고_뒤_것은_터짐(world): +def test_동시_지우기와_합치기_앞_것만_됨_뒤_합치기는_409(world): me = world["personal"] gone = _sk(me, "겹침", 1000) keep = _sk(me, "겹침", 1000, again=True) @@ -454,16 +447,13 @@ def test_동시_지우기와_합치기_앞_것이_이기고_뒤_것은_터짐(wo body = same_router.MergeBody( 남김={"층": "personal", "주인": "7/42", "키": keep}, 지움=[gone], 판=판 ) - first, second = _two( + first, second = _race( _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"), + (pre_folders, "apply_many"), ) assert first["알림"]["기록"] == gone # 지우기 = 됨(기록 키 = 그 문서) - # 5-4 에서 뒤집을 단언 — 지금은 뒤 합치기가 판 · 지문 대조를 지난 뒤 사라진 파일에서 터짐 - # (화면 = 500) · 5-4 뒤 = 409 · 파일 앞판 그대로 - assert isinstance(second, FileNotFoundError) + 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] # 지우기 기록만