Merge remote-tracking branch 'origin/sub_laptop_3' into sub_laptop_7

resources/tester/test_707_7_whole_import.py

@@ -181,8 +181,8 @@ def test_내_자료집에_저장_하위_호표_같이_한_번(world, monkeypatch
     saved = {p.stem: json.loads(p.read_text("utf-8")) for p in (folder / "precombo").glob("*.json")}
     for key in keys:
         for one in saved[key]["담은로직"]:
-            if "참조" in one:
-                assert one["참조"]["층"] == "personal" and one["참조"]["키"] in saved
+            if "참조" in one:  # 740-1 하위 호표 = 사본 블록(본뜬 = 같이 만든 개인 SC)
+                assert one["참조"]["층"] == "사본" and one["본뜬"]["키"] in saved
     copied = [d["본뜬"]["복사원본"] for d in saved.values() if "복사원본" in (d.get("본뜬") or {})]
     assert len(copied) == len({json.dumps(x, sort_keys=True) for x in copied})  # 같은 하위 한 번
     for p in (folder / "precombo").glob("*.json"):  # 다음 시험에 층 쓰기 안 남김

resources/tester/test_733_2_library_ask.py

@@ -93,23 +93,23 @@ def test_공유_승인_회사_같은_내용_409_씀_새로(world):
 
 
 def test_복사_딸림_같은_원본_재사용(world):
+    """구조물 조합 복사 딸림(733-2) = 같은 원본 사본 재사용 · 740-1 — 일위대가 안 일위대가는
+    넣을 때 사본 블록(딸림 없음)."""
     client = _client(world)
     _as(world)
-    mine = layers.personal_dir(7, 42)
     url = LIB.format("personal", "precombo")
     inner = client.post(url, json=_doc("안")).json()["이름"]
     ref = {"층": "personal", "주인": "7/42", "키": inner}
     outer = {"문서": {"이름": "밖", "단위": "㎡", "담은로직": [{"참조": ref}]}}
     top = client.post(url, json=outer).json()["이름"]
-    with store.at(mine):
-        doc = store.read("precombo", top)["문서"]
-    src = {"층": "personal", "주인": "7/42", "키": top}
+    with store.at(layers.personal_dir(7, 42)):
+        assert store.read("precombo", top)["문서"]["담은로직"][0]["참조"]["층"] == "사본"
     company = layers.company_dir(7)
+    combo = {"종류": "일위대가", "열": "rv", "담은로직": [{"참조": ref}], "자재": []}
     with store.at(company):
-        one = refs.create("precombo", refs.carry(refs.origin_mark(doc, src), ("personal", "7/42")))
-        assert _count(company) == 2  # 밖 + 딸린 안
-        two = refs.create("precombo", refs.carry(refs.origin_mark(doc, src), ("personal", "7/42")))
-    assert _count(company) == 3  # 다시 복사 = 밖만 새로 · 딸린 안 = 앞 사본 재사용
-    with store.at(company):
-        got = [store.read("precombo", m["이름"])["문서"]["담은로직"][0]["참조"] for m in (one, two)]
+        one = refs.carry(combo, ("personal", "7/42"))
+        assert _count(company) == 1  # 딸린 안 = 회사 새 키
+        two = refs.carry(combo, ("personal", "7/42"))
+    assert _count(company) == 1  # 다시 복사 = 앞 사본 재사용
+    got = [x["담은로직"][0]["참조"] for x in (one, two)]
     assert got[0] == got[1] and got[0]["층"] == "company"

resources/tester/test_735_1_library_delete.py

@@ -136,7 +136,9 @@ def test_폴더_통째_한_기록_되돌림_자리까지_그새_고친_문서는
     a = _sc(me, "가", [FIX])
     b = _sc(me, "나", [FIX])
     _labor(me, [{"참조": {**MINE, "키": a}, "수량": {"손": 1}}, FIX])
-    other = _sc(me, "다른", [{"참조": {**MINE, "키": b}}, FIX])
+    with store.at(me):  # 쓰는 곳 = 구조물 조합(740-1 — 일위대가 안 일위대가는 사본 블록)
+        other = [{"참조": {**MINE, "키": b}, "수량": {"손": 1}}, FIX]
+        store.write("labor", "x2", "", {"열": "x2", "담은로직": other, "자재": []})
     assert _tree(api, op="add-folder", 경로=[], 이름="묶음").status_code == 200
     for key in (a, b):
         assert _tree(api, op="move", 키=key, 새경로=["묶음"]).status_code == 200
@@ -147,9 +149,10 @@ def test_폴더_통째_한_기록_되돌림_자리까지_그새_고친_문서는
     assert res.status_code == 200, res.text
     name = res.json()["알림"]["기록"]
     assert [g["키"] for g in api.get(SAME).json()["합친것"]] == [name]
-    with store.at(me):  # 그새 「다른」 을 고침 → 그 문서는 앞판으로 안 돌림
-        have = store.read("precombo", other)
-        store.write("precombo", other, have["판"], {**have["문서"], "이름": "다른 고침"})
+    with store.at(me):  # 그새 x2 를 고침 → 그 문서는 앞판으로 안 돌림
+        have = store.read("labor", "x2")
+        lines = [{**x, "메모": "고침"} for x in have["문서"]["담은로직"]]
+        store.write("labor", "x2", have["판"], {**have["문서"], "담은로직": lines})
     back = api.post(SAME + "/undo", json={"키": name}).json()
     assert back["되돌린곳수"] == 1 and "그새 고침" in back["못한곳"][0]
     assert (me / "precombo" / f"{a}.json").is_file() and (me / "precombo" / f"{b}.json").is_file()

resources/tester/test_740_1_library_flat.py

@@ -140,7 +140,8 @@ def test_SC_에_SK_패치_겹침_E1_원본_고쳐도_그대로(world):
     doc = _read(me, "precombo", host)
     assert doc["담은로직"][0]["로직"] == PCT and doc["담은로직"][0]["본뜬"]["키"] == sk
     assert doc["담은로직"][0]["패치"]["덮개"] == {"labor:LB000036#0": {"qty": 0.5}}
-    assert doc["담은로직"][1]["참조"]["키"] == inner  # 하위 호표(SC 안 SC) = 참조 그대로
+    assert doc["담은로직"][1]["참조"]["층"] == "사본"  # 하위 호표(SC 안 SC) = 사본 블록
+    assert doc["담은로직"][1]["본뜬"]["키"] == inner
     assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)
     with store.at(me):  # E1 — 원본 SK 의 덮지 않은 줄 품 2
         now = store.read("sangeun", sk)
@@ -151,33 +152,28 @@ def test_SC_에_SK_패치_겹침_E1_원본_고쳐도_그대로(world):
     assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)  # 펼친 것 = 그대로
 
 
-def test_SC_에_SC_펴넣기_실무수량_겹침_넣기_400(world):
+def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world):
+    """하위 호표(SC 안 SC) = 사본 블록 — 원본 연결 없음 · 금액 같음 · 같은 기초 겹침도 블록 안."""
     me = world["personal"]
     hands = {"층": "실무자료", "실무수량": {"줄": {"0": 3}, "자재": {}}}
     inner = _make(me, "precombo", 이름="안", 담은로직=[{"로직": PCT}], 본뜬=hands)
-    outer_hands = {"층": "실무자료", "실무수량": {"줄": {"0": 2, "1": 5}, "자재": {}}}
-    lines = [{"로직": GF}, {"참조": {**MINE, "키": inner}, "별칭": "안쪽"}]
-    old = _raw(me, "precombo", 이름="옛", 담은로직=lines, 본뜬=outer_hands)
-    assert flat.flat_doc("precombo", _read(me, "precombo", old))["담은로직"][1][
-        "참조"
-    ]  # 저장 · 읽기
-    got = flat.flat_sc(_read(me, "precombo", old), refs.read_ref, _whole())  # 넣기 길 = 펴 넣음
-    assert [x["로직"] for x in got["담은로직"]] == [GF, PCT] and got["담은로직"][1][
-        "별칭"
-    ] == "안쪽"
-    assert got["본뜬"]["실무수량"]["줄"] == {"0": 2, "1": 15}  # 바깥 5 × 안 3
-
-    def mine(r):
-        return got if r["키"] == old else refs.read_ref(r)
-
-    assert _sc_value(me, old, mine) == pytest.approx(_sc_value(me, old), rel=1e-9)
-    # 같은 기초가 겹침 — 넣기 길 = 400
-    dup = [{"로직": PCT}, {"참조": {**MINE, "키": inner}}]
-    kept = _make(me, "precombo", 이름="겹침", 담은로직=dup)
-    assert _read(me, "precombo", kept)["담은로직"][1]["참조"]["키"] == inner
-    with store.at(me), pytest.raises(store.StoreError) as e:
-        flat.flat_lines("precombo", {**MINE, "키": inner}, None, {"담은로직": [{"로직": PCT}]})
-    assert e.value.status == 400 and "겹침" in str(e.value.detail)
+    lines = [{"로직": PCT}, {"참조": {**MINE, "키": inner}, "별칭": "안쪽"}]  # 같은 기초 겹침
+    old = _raw(me, "precombo", 이름="옛", 담은로직=lines)
+    before = _sc_value(me, old)
+    host = _make(me, "precombo", 이름="밖", 담은로직=lines)
+    line = _read(me, "precombo", host)["담은로직"][1]
+    block = line["참조"]
+    assert block["층"] == "사본" and block["키"] == inner and line["본뜬"]["키"] == inner
+    assert block["몸"]["담은로직"][0]["로직"] == PCT and line["별칭"] == "안쪽"
+    assert block["몸"]["본뜬"]["실무수량"]["줄"] == {"0": 3}  # 엑셀 대조 · 하위 호표 끝수
+    assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)
+    with store.at(me):
+        got = flat.flat_lines("precombo", {**MINE, "키": old}, None, {"담은로직": [{"로직": GF}]})
+        (me / "precombo" / f"{old}.json").unlink()  # 옛 꼴 문서(참조) 치움
+        assert refs.users({**MINE, "키": inner}) == []
+        store.delete("precombo", inner)
+    assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)  # 원본 지워도 그대로
+    assert got["담은로직"][0]["참조"]["층"] == "사본"  # 넣기 길도 블록(겹침 없음)
 
 
 def test_SK_에_SC_줄마다_더한줄(world):
@@ -192,10 +188,9 @@ def test_SK_에_SC_줄마다_더한줄(world):
 
     hand = flat.sc_adds({"담은로직": [{"로직": GF, "수량": {"손": 3}}]}, Decimal(2), _whole(), {})
     assert hand[0]["수량"] == 6
-    lines, _, _ = flat._spread(
-        {"담은로직": [{"로직": GF, "수량": {"손": 3}}]}, {"수량": {"손": 2}}, None, {}
-    )
-    assert lines[0]["수량"] == {"손": 6}
+    block = {"참조": refs.copy_ref({"담은로직": [{"로직": GF, "수량": {"손": 3}}]}, "SC-000001")}
+    deep = flat.sc_adds({"담은로직": [{**block, "수량": {"손": 2}}]}, Decimal(1), _whole(), {})
+    assert deep[0]["로직"] == GF and deep[0]["수량"] == 6  # 사본 블록 = 바깥 × 안
     doc = {"키": "SK-000099", "이름": "x", "단위": "㎥", "바탕": None, "더한줄": got}
     one = float(labor.run_line(_whole(), GF, {})["기준"]["계"])
     assert _sk_total(me, doc) == pytest.approx(2 * one, rel=1e-9)
@@ -267,7 +262,20 @@ def test_초기화_SK_SC_M01_값_옵션_남음(world):
     with store.at(me):
         got = flat.reset_doc("precombo", sc, None, False, None)
     line = _read(me, "precombo", sc)["담은로직"][0]
-    assert got["걷힘"] == 2 and line["패치"] == {"더한줄": [{**ADD, "수량": 0.5}]}
+    assert got["걷힘"] == 2 and line["패치"] == {"더한줄": [{**ADD, "수량": 0.5, "처음수량": 0.5}]}
+    # 이음 기계 고정 줄(736-3) = M01 기계 한 시간 값 다시 받음
+    from M02_MasterTemplete import M02_Machine_Hourly as machine
+
+    hour = machine.hourly("EQ000019")
+    fx = {"이름": "굴착기", "단위": "시간", "단가": {"노무비": 1, "재료비": 1, "경비": 1}}
+    fx["이음"] = {"기계": "EQ000019"}
+    mc = _make(me, "precombo", 이름="기계", 담은로직=[{"고정": fx}])
+    with store.at(me):
+        assert flat.reset_doc("precombo", mc, None, False, None)["걷힘"] == 1
+    price = _read(me, "precombo", mc)["담은로직"][0]["고정"]["단가"]
+    assert price["노무비"] == pytest.approx(hour["노무비"]) and price["경비"] == pytest.approx(
+        hour["경비"]
+    )
 
 
 def test_길_넣기_초기화_권한(world):
@@ -289,7 +297,7 @@ def test_길_넣기_초기화_권한(world):
     assert firm.status_code == 403  # 일반 사용자 회사 층 쓰기 막힘
 
 
-def test_옮기기_함수_전후_같음_겹침_남김(world):
+def test_옮기기_함수_전후_같음_사본_블록(world):
     me = world["personal"]
     y = _y(me)
     inner = _make(me, "precombo", 이름="안", 담은로직=[{"로직": GF}])
@@ -314,18 +322,18 @@ def test_옮기기_함수_전후_같음_겹침_남김(world):
         sk: _sk_total(me, _read(me, "sangeun", sk))
     }
     look = {r["키"]: r for r in flat.migrate(False)}
-    assert look[sk]["같음"] and look[sc]["같음"] and not look[sc]["씀"]
-    assert look[sc]["남은참조"] == look[dup]["남은참조"] == [inner]  # 하위 호표 = 그대로
+    assert all(look[k]["같음"] and look[k]["펼침"] and not look[k]["씀"] for k in (sk, sc, dup))
     rows = {r["키"]: r for r in flat.migrate(True)}
-    assert rows[sk]["씀"] and rows[sc]["씀"] and not rows[dup]["씀"]
+    assert all(rows[k]["씀"] for k in (sk, sc, dup))
     assert not refs.refs_in(json.loads((me / "sangeun" / f"{sk}.json").read_bytes()))
-    left = refs.refs_in(json.loads((me / "precombo" / f"{sc}.json").read_bytes()))
-    assert [r["키"] for r in left] == [inner]
+    for key in (sc, dup):  # 하위 호표 = 사본 블록만 남음(원본 연결 없음)
+        left = refs.refs_in(json.loads((me / "precombo" / f"{key}.json").read_bytes()))
+        assert [(r["층"], r["키"]) for r in left] == [("사본", inner)]
     assert _sk_total(me, _read(me, "sangeun", sk)) == pytest.approx(before[sk], rel=1e-9)
     assert _sc_value(me, sc) == pytest.approx(before[sc], rel=1e-9)
     assert _sc_value(me, dup) == pytest.approx(before[dup], rel=1e-9)
-    again = flat.migrate(False)  # 두 번째 = 하위 호표 참조만 남음(바꿀 것 없음)
-    assert [r["키"] for r in again] == [sc, dup] and all(r["남은참조"] == [inner] for r in again)
+    again = flat.migrate(True)  # 두 번째 = 바꿀 것 없음
+    assert all(r["펼침"] and not r["씀"] for r in again)
 
 
 def test_733_지문_옛_참조_펼친_것_같음(world):

resources/tester/test_744_1_sk_detail_undo.py

@@ -0,0 +1,89 @@
+# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
+"""744-1 서버 — 둘째 기초 세부 품 원문 · 되돌리기 기억(임시 storage · M01 읽기만).
+
+- 둘째 기초 `펼침` 줄 `원문` = 그 기초 1 기준단위 몫(GF000316 품 그대로) · 줄 수량 · 금액 = 머리
+  수량 곱한 몫(상자 합) 그대로 · 머리 수량 = 더한줄 수량
+- 더한줄 `처음수량` = 넣을 때 수량(없으면 저장 때 지금 수량) · 셈 · 지문 안 듦
+- `뺀더한줄 [{차례, 줄}]` = [기초 빼기] · 더한 항목 빼기 기억 · 셈 · 지문 안 듦 · 못 읽는 줄 버림 ·
+  일위대가 줄 패치도 같음
+"""
+
+import pytest
+
+from M01_MasterData import M01_MasterData_Store as m01
+from M02_MasterTemplete import M02_Labor_Doc as labor
+from M02_MasterTemplete import M02_Labor_Ref as refs
+from M02_MasterTemplete import M02_Library_Same as same
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete import M02_Sangeun_Calc as calc
+from resources.tester.test_m02_labor_ref import world  # noqa: F401
+
+GF = "GF000099"  # 원/㎥
+BIG = "GF000316"  # 기준단위 100㎥ — ㎥ 바탕에서 처음 수량 0.01
+PCT = "GC001109"
+MAN = {"종류": "인력", "요소": "LB000002", "수량": 1}
+
+
+def _sk(folder, **doc):
+    with store.at(folder):
+        made = refs.create("sangeun", {"이름": "744", "단위": "㎥", "더한줄": [], **doc})
+        return store.read("sangeun", made["이름"])["문서"]
+
+
+def _calc(folder, doc):
+    with store.at(folder):
+        return calc.calc_doc(doc)
+
+
+def test_둘째_기초_세부_원문_품_머리_수량(world):
+    doc = _sk(
+        world["personal"], 바탕={"로직": GF}, 더한줄=[{"종류": "로직", "로직": BIG, "수량": 0.01}]
+    )
+    got = _calc(world["personal"], doc)
+    head = next(x for x in got["줄"] if x["cid"] == "add:#0")
+    m01_lines = labor.run_line(m01.loaded()[1], BIG, {})["줄"]
+    assert head["수량"] == pytest.approx(0.01)
+    for row, line in zip(head["펼침"], m01_lines):
+        assert row["원문"]["수량"] == pytest.approx(float(line["수량"]), rel=1e-9)  # 원문 그대로
+        assert row["수량"] == pytest.approx(float(line["수량"]) * 0.01, rel=1e-9)  # 상자 몫
+    assert sum(x["금액"] for x in head["펼침"]) == pytest.approx(head["금액"], rel=1e-9)
+    assert sum(x["원문"]["금액"] for x in head["펼침"]) * 0.01 == pytest.approx(head["금액"])
+
+
+def test_처음수량_넣을때_값_셈_지문_안_듦(world):
+    me = world["personal"]
+    plain = _sk(me, 바탕={"로직": PCT}, 단위="㎡", 더한줄=[{**MAN, "수량": 3}])
+    assert plain["더한줄"][0]["처음수량"] == 3  # 없으면 저장 때 지금 수량
+    kept = _sk(me, 바탕={"로직": PCT}, 단위="㎡", 더한줄=[{**MAN, "수량": 3, "처음수량": 1}])
+    assert kept["더한줄"][0]["처음수량"] == 1
+    assert _calc(me, kept)["기준"]["계"] == _calc(me, plain)["기준"]["계"]
+    assert same.finger("sangeun", kept) == same.finger("sangeun", plain)
+
+
+def test_뺀더한줄_기억_셈_지문_안_듦_못읽는_줄_버림(world):
+    me = world["personal"]
+    gone = [
+        {"차례": 0, "줄": {"종류": "로직", "로직": BIG, "수량": 0.01, "덮개": {}}},
+        {"차례": 1, "줄": MAN},
+        {"차례": -1, "줄": MAN},  # 차례 틀림
+        {"차례": 2, "줄": {"종류": "로직", "로직": "GX999999", "수량": 1}},  # 없는 기초
+        {"차례": 3},  # 줄 없음
+    ]
+    doc = _sk(me, 바탕={"로직": GF}, 뺀더한줄=gone)
+    assert [x["차례"] for x in doc["뺀더한줄"]] == [0, 1]
+    assert doc["뺀더한줄"][1]["줄"]["요소"] == "LB000002"
+    bare = _sk(me, 바탕={"로직": GF})
+    assert _calc(me, doc)["기준"]["계"] == _calc(me, bare)["기준"]["계"]
+    assert same.finger("sangeun", doc) == same.finger("sangeun", bare)
+
+
+def test_일위대가_줄_패치_기억_처음수량(world):
+    me = world["personal"]
+    patch = {"더한줄": [{**MAN, "수량": 2}], "뺀더한줄": [{"차례": 0, "줄": MAN}]}
+    with store.at(me):
+        sc = refs.create(
+            "precombo", {"이름": "744", "단위": "㎡", "담은로직": [{"로직": PCT, "패치": patch}]}
+        )
+        line = store.read("precombo", sc["이름"])["문서"]["담은로직"][0]
+    assert line["패치"]["더한줄"][0]["처음수량"] == 2
+    assert line["패치"]["뺀더한줄"][0]["줄"]["요소"] == "LB000002"

resources/tester/test_m02_hopyo_build.py

@@ -250,7 +250,9 @@ def test_하위_호표_먼저_확인_퍼센트_빠짐_통째(client):
     mine = layers.personal_dir(7, 42)
     made = _doc(mine, got["참조"]["키"])
     line = made["담은로직"][0]
-    assert line["참조"] == child["참조"] and line["별칭"] == "고화매트재료비"
+    # 740-1 하위 호표 = 사본 블록(원본 연결 없음 · 키 = 출처)
+    assert line["참조"]["층"] == "사본" and line["참조"]["키"] == child["참조"]["키"]
+    assert line["본뜬"]["키"] == child["참조"]["키"] and line["별칭"] == "고화매트재료비"
     assert line["수량"] is None and made["본뜬"]["실무수량"]["줄"]["0"] == 2.3  # 723-1
     assert "고화매트재료비||m2" not in _book(mine)  # 호표 참조 줄 = 장부 안 씀
     whole = _build(client, 3, 통째={"대상": [{"로직": "GF000101", "배": 1}]})

resources/tester/test_m02_labor_ref.py

@@ -179,18 +179,18 @@ def test_사전조합_틀린_줄_400_순환_422(world):
         with pytest.raises(store.StoreError) as e:
             _combo(world["system"], lines)
         assert e.value.status == 400
+    # 740-1 — 사전조합에 사전조합 = 사본 블록(원본 연결 없음) · 되돌려 담아도 순환 없음
     a = _combo(world["system"], [one], "가")
     b = _combo(world["system"], [{"참조": {**SYS, "키": a}}], "나")
     with store.at(world["system"]):
+        line = store.read("precombo", b)["문서"]["담은로직"][0]
+        assert line["참조"]["층"] == "사본" and line["본뜬"]["키"] == a
+        assert line["참조"]["몸"]["담은로직"][0]["참조"] == one["참조"]
         have = store.read("precombo", a)
-        with pytest.raises(store.StoreError) as e:
-            store.write(
-                "precombo",
-                a,
-                have["판"],
-                {**have["문서"], "담은로직": [{"참조": {**SYS, "키": b}}]},
-            )
-    assert e.value.status == 422 and f"{a} → {b} → {a}" in e.value.detail
+        store.write(
+            "precombo", a, have["판"], {**have["문서"], "담은로직": [{"참조": {**SYS, "키": b}}]}
+        )
+        assert store.read("precombo", a)["문서"]["담은로직"][0]["참조"]["층"] == "사본"
 
 
 def test_층_규칙은_위_층만(world):
@@ -329,11 +329,12 @@ def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):
         )
     got = _read(world["company"], "precombo", made["이름"])
     assert got["본뜬"] == {**MINE, "키": sc}
-    assert [one["참조"] for one in got["담은로직"]] == [
-        {**COMPANY, "키": "SC-000001"},  # 회사가 못 읽는 개인 사전조합 → 회사 층 새 키
-        {**SYS, "키": sys_sp},  # 마스터는 그대로(옛 승격도)
-    ]
-    assert _read(world["company"], "precombo", "SC-000001")["본뜬"] == {**MINE, "키": inner}
+    # 740-1 — 개인 사전조합은 넣을 때 사본 블록(본뜬) → 회사로 따로 복사 안 함 ·
+    # 마스터 옛 승격 그대로
+    block = got["담은로직"][0]
+    assert block["참조"]["층"] == "사본" and block["본뜬"]["키"] == inner
+    assert got["담은로직"][1]["참조"] == {**SYS, "키": sys_sp}
+    assert made["이름"] == "SC-000001"  # 딸림 복사 없음
     # 못 읽는 옛 개인 승격은 따라 복사 안 함(134-2 · 승격 서고 없음)
     mine_sp = _promote(world["personal"])
     with store.at(world["company"]), pytest.raises(store.StoreError) as e: