From 309b781c0e6e3e1fa0f24910b2646889ce86b39d Mon Sep 17 00:00:00 2001 From: zlwu <704541015@qq.com> Date: Wed, 19 Aug 2026 11:22:15 +0800 Subject: [PATCH] feat: add dual-gate storage release pure functions and tests. Co-authored-by: Cursor --- backend/app/crud/storage_release_review.py | 74 +++++++++++++++ .../tests/test_storage_release_dual_gate.py | 93 +++++++++++++++++++ 2 files changed, 167 insertions(+) create mode 100644 backend/tests/test_storage_release_dual_gate.py diff --git a/backend/app/crud/storage_release_review.py b/backend/app/crud/storage_release_review.py index 11a29313..729ea337 100644 --- a/backend/app/crud/storage_release_review.py +++ b/backend/app/crud/storage_release_review.py @@ -135,6 +135,80 @@ def normalize_review_phase(review_phase: Optional[str]) -> Optional[str]: return None +def conclusion_blank(value: Optional[str]) -> bool: + return not (value or "").strip() + + +def aggregate_review_conclusion( + prod: Optional[str], qc: Optional[str] +) -> Optional[str]: + p = (prod or "").strip() + q = (qc or "").strip() + if p == "btg" or q == "btg": + return "btg" + if p == "tg" and q == "tg": + return "tg" + return None + + +def storage_transition( + prod: Optional[str], qc: Optional[str], storage_status: Optional[str] +) -> str: + """Return 'store' | 'unstore' | 'noop'.""" + agg = aggregate_review_conclusion(prod, qc) + st = (storage_status or "drk").strip() or "drk" + if agg == "tg" and st == "drk": + return "store" + if agg == "btg" and st == "yrk": + return "unstore" + return "noop" + + +def normalize_review_side(raw: Optional[str]) -> Optional[str]: + s = (raw or "").strip().lower() + if s in ("overview", "production", "qc"): + return s + return None + + +def review_side_required_menu(review_side: Optional[str]) -> Optional[str]: + if review_side == "production": + return "production:storageReleaseReview:list" + if review_side == "qc": + return "quality:storageReleaseReview:list" + return None + + +def matches_dual_review_phase( + review_side: Optional[str], + phase: Optional[str], + prod: Optional[str], + qc: Optional[str], +) -> bool: + """Pure predicate for Tab semantics; SQL filter must match this.""" + side = normalize_review_side(review_side) or "overview" + ph = normalize_review_phase(phase) + if not ph: + return True + prod_blank = conclusion_blank(prod) + qc_blank = conclusion_blank(qc) + if side == "production": + return prod_blank if ph == "pending" else (not prod_blank) + if side == "qc": + return qc_blank if ph == "pending" else (not qc_blank) + both_filled = (not prod_blank) and (not qc_blank) + return (not both_filled) if ph == "pending" else both_filled + + +def should_copy_legacy_to_qc( + qc_review_conclusion: Optional[str], + legacy_review_conclusion: Optional[str], +) -> bool: + return conclusion_blank(qc_review_conclusion) and not conclusion_blank( + legacy_review_conclusion + ) + + def normalize_qc_work_order_completed(raw) -> Optional[bool]: """Return True/False when recognizable; None means no filter.""" if raw is None: diff --git a/backend/tests/test_storage_release_dual_gate.py b/backend/tests/test_storage_release_dual_gate.py new file mode 100644 index 00000000..1ac6b350 --- /dev/null +++ b/backend/tests/test_storage_release_dual_gate.py @@ -0,0 +1,93 @@ +from app.crud.storage_release_review import ( + aggregate_review_conclusion, + conclusion_blank, + matches_dual_review_phase, + normalize_review_side, + review_side_required_menu, + should_copy_legacy_to_qc, + storage_transition, +) + + +def test_conclusion_blank(): + assert conclusion_blank(None) is True + assert conclusion_blank("") is True + assert conclusion_blank(" ") is True + assert conclusion_blank("tg") is False + assert conclusion_blank("btg") is False + + +def test_aggregate_both_tg(): + assert aggregate_review_conclusion("tg", "tg") == "tg" + + +def test_aggregate_any_btg(): + assert aggregate_review_conclusion("btg", "tg") == "btg" + assert aggregate_review_conclusion("tg", "btg") == "btg" + assert aggregate_review_conclusion("btg", None) == "btg" + assert aggregate_review_conclusion("", "btg") == "btg" + + +def test_aggregate_pending_when_not_aligned(): + assert aggregate_review_conclusion("tg", None) is None + assert aggregate_review_conclusion(None, "tg") is None + assert aggregate_review_conclusion(None, None) is None + assert aggregate_review_conclusion("", "") is None + + +def test_storage_transition_store_when_both_tg_and_pending(): + assert storage_transition("tg", "tg", "drk") == "store" + + +def test_storage_transition_unstore_when_btg_and_stored(): + assert storage_transition("btg", "tg", "yrk") == "unstore" + assert storage_transition("tg", "btg", "yrk") == "unstore" + + +def test_storage_transition_noop_otherwise(): + assert storage_transition("tg", "tg", "yrk") == "noop" + assert storage_transition("tg", None, "drk") == "noop" + assert storage_transition("btg", "tg", "drk") == "noop" + assert storage_transition(None, None, "yrk") == "noop" + + +def test_matches_dual_review_phase_production(): + assert matches_dual_review_phase("production", "pending", None, "tg") is True + assert matches_dual_review_phase("production", "pending", "tg", "tg") is False + assert matches_dual_review_phase("production", "reviewed", "btg", None) is True + assert matches_dual_review_phase("production", "reviewed", None, "tg") is False + + +def test_matches_dual_review_phase_qc(): + assert matches_dual_review_phase("qc", "pending", "tg", None) is True + assert matches_dual_review_phase("qc", "reviewed", "tg", "tg") is True + assert matches_dual_review_phase("qc", "reviewed", "tg", None) is False + + +def test_matches_dual_review_phase_overview(): + assert matches_dual_review_phase("overview", "pending", None, "tg") is True + assert matches_dual_review_phase("overview", "pending", "tg", "tg") is False + assert matches_dual_review_phase("overview", "reviewed", "tg", "btg") is True + assert matches_dual_review_phase("overview", "reviewed", "tg", None) is False + + +def test_should_copy_legacy_to_qc(): + assert should_copy_legacy_to_qc(None, "tg") is True + assert should_copy_legacy_to_qc("", "btg") is True + assert should_copy_legacy_to_qc("tg", "tg") is False + assert should_copy_legacy_to_qc(None, None) is False + assert should_copy_legacy_to_qc(None, "") is False + + +def test_normalize_review_side(): + assert normalize_review_side("production") == "production" + assert normalize_review_side(" QC ") == "qc" + assert normalize_review_side("overview") == "overview" + assert normalize_review_side("all") is None + assert normalize_review_side(None) is None + + +def test_review_side_required_menu(): + assert review_side_required_menu("production") == "production:storageReleaseReview:list" + assert review_side_required_menu("qc") == "quality:storageReleaseReview:list" + assert review_side_required_menu("overview") is None