hap-cli 0.5.0__py3-none-any.whl

hap_cli/tests/test_integration.py

@@ -0,0 +1,805 @@
+"""Real integration tests for hap-cli against live HAP API.
+
+These tests hit the real API and require a configured session.
+Run: hap config set --server <url> --token <token>
+
+Design:
+  - The test WORKSHEET is persistent (created once, reused across runs).
+  - Transient resources (views, buttons, records, workflows) are created and
+    cleaned up within each run.
+  - The state file persists worksheet/section IDs between runs; transient IDs
+    are removed during cleanup.
+
+Usage:
+    cd agent-harness
+    python -m pytest hap_cli/tests/test_integration.py -v -s
+"""
+
+import json
+from pathlib import Path
+
+import pytest
+
+# ── Paths ──────────────────────────────────────────────────────────────────
+
+_TESTS_DIR = Path(__file__).parent
+_CONFIG_FILE = _TESTS_DIR / "integration_config.json"
+_STATE_FILE = _TESTS_DIR / "integration_state.json"
+
+# ── Config ─────────────────────────────────────────────────────────────────
+
+_cfg = json.loads(_CONFIG_FILE.read_text())
+PROJECT_ID: str = _cfg["project_id"]
+APP_ID: str = _cfg["app_id"]
+
+TEST_SECTION_NAME = "Integration Tests"
+TEST_WORKSHEET_NAME = "Integration Test Worksheet"
+TEST_WORKFLOW_NAME = "Integration Test Workflow"
+
+# ── Imports ────────────────────────────────────────────────────────────────
+
+from hap_cli.core.session import Session
+from hap_cli.core import app as app_mod
+from hap_cli.core import worksheet as ws_mod
+from hap_cli.core import workflow as wf_mod
+from hap_cli.core import flow_node as node_mod
+from hap_cli.core import record as rec_mod
+
+
+# ── State helpers ──────────────────────────────────────────────────────────
+
+def _load_state() -> dict:
+    if _STATE_FILE.exists():
+        try:
+            return json.loads(_STATE_FILE.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def _save_state(state: dict) -> None:
+    _STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False))
+
+
+# Transient keys that are cleaned up at the end of each run
+_TRANSIENT_KEYS = {"view_id", "gallery_view_id", "button_id", "row_id",
+                   "process_id", "node_id", "name_control_id"}
+
+# Persistent keys that survive cleanup (worksheet/section)
+_PERSISTENT_KEYS = {"worksheet_id", "section_id", "controls"}
+
+
+def _cleanup_transient(session: Session, state: dict) -> None:
+    """Clean up resources created during this run (not the worksheet itself)."""
+    errors = []
+
+    # Delete the auto-created workflow (process linked to the button)
+    if pid := state.get("process_id"):
+        try:
+            wf_mod.delete_process(session, pid)
+            print(f"  [cleanup] deleted process {pid}")
+        except Exception as e:
+            errors.append(f"process {pid}: {e}")
+
+    # Delete the button itself (SaveWorksheetBtn with isDelete=True)
+    ws_id = state.get("worksheet_id")
+    if ws_id and (btn_id := state.get("button_id")):
+        try:
+            ws_mod.delete_button(session, ws_id, btn_id)
+            print(f"  [cleanup] deleted button {btn_id}")
+        except Exception as e:
+            errors.append(f"button {btn_id}: {e}")
+
+    if errors:
+        print(f"  [cleanup] non-fatal warnings: {errors}")
+
+    # Remove transient keys from state, keep persistent ones
+    for key in list(state.keys()):
+        if key in _TRANSIENT_KEYS:
+            del state[key]
+    _save_state(state)
+
+
+# ── Section / Worksheet helpers ────────────────────────────────────────────
+
+def _get_or_create_section(session: Session, state: dict) -> str:
+    """Return a section ID for testing, creating one if needed."""
+    # Check saved state first
+    if sid := state.get("section_id"):
+        return sid
+
+    # Fetch app info to find existing sections
+    info = app_mod.get_app_info(session, APP_ID)
+    sections = info.get("sections", [])
+    for sec in sections:
+        if sec.get("name") == TEST_SECTION_NAME:
+            sid = sec.get("id") or sec.get("sectionId")
+            state["section_id"] = sid
+            _save_state(state)
+            print(f"  Found existing section: {sid}")
+            return sid
+
+    # Create a new section
+    result = session.api_call("HomeApp", "AddAppSection", {
+        "appId": APP_ID,
+        "name": TEST_SECTION_NAME,
+    })
+    # Response: {'code': 1, 'data': '<section_id>'}
+    sid = (result.get("data") if isinstance(result, dict) else str(result))
+    assert sid, f"Could not create section: {result}"
+    state["section_id"] = sid
+    _save_state(state)
+    print(f"  Created section: {sid}")
+    return sid
+
+
+def _get_or_create_worksheet(session: Session, state: dict, section_id: str) -> str:
+    """Return worksheet ID, reusing an existing one if available."""
+    # Reuse saved worksheet if it still exists
+    if ws_id := state.get("worksheet_id"):
+        try:
+            ws_mod.get_worksheet_info(session, ws_id, app_id=APP_ID)
+            print(f"  Reusing existing worksheet: {ws_id}")
+            return ws_id
+        except Exception:
+            print(f"  Saved worksheet {ws_id} no longer exists — will create new")
+            state.pop("worksheet_id", None)
+            state.pop("controls", None)
+
+    # Create worksheet
+    result = ws_mod.create_worksheet(
+        session,
+        app_id=APP_ID,
+        name=TEST_WORKSHEET_NAME,
+        section_id=section_id,
+    )
+    assert result, f"create_worksheet returned empty: {result}"
+
+    ws_id = None
+    if isinstance(result, dict):
+        ws_id = (result.get("workSheetId") or result.get("worksheetId")
+                 or result.get("id") or result.get("data"))
+        if isinstance(ws_id, dict):
+            ws_id = ws_id.get("workSheetId") or ws_id.get("worksheetId")
+    if not ws_id:
+        ws_id = str(result)
+
+    assert ws_id, f"Could not extract worksheetId from: {result}"
+    state["worksheet_id"] = ws_id
+    _save_state(state)
+    print(f"  Created worksheet: {ws_id}")
+    return ws_id
+
+
+# ── Fixtures ───────────────────────────────────────────────────────────────
+
+@pytest.fixture(scope="module")
+def session():
+    s = Session.load()
+    if not s.is_configured():
+        pytest.skip(
+            "HAP session not configured. Run: hap config set --server <url> --token <token>"
+        )
+    return s
+
+
+@pytest.fixture(scope="module")
+def state():
+    """Module-wide mutable state dict, pre-loaded from state file."""
+    return _load_state()
+
+
+# ── Tests: Setup ───────────────────────────────────────────────────────────
+
+class TestSetup:
+
+    def test_00_cleanup_previous_run(self, session, state):
+        """Clean up only transient resources from the previous run."""
+        transient_found = any(k in state for k in _TRANSIENT_KEYS)
+        if transient_found:
+            print(f"\n  Cleaning transient keys from previous run: "
+                  f"{[k for k in _TRANSIENT_KEYS if k in state]}")
+            _cleanup_transient(session, state)
+        else:
+            print("\n  No transient state found — clean start.")
+
+    def test_01_verify_app_access(self, session, state):
+        """Verify connectivity to the target application."""
+        result = app_mod.get_app_info(session, APP_ID)
+        assert result, "get_app_info returned empty"
+        name = result.get("name", "(unknown)")
+        print(f"\n  App: {name}  (id={APP_ID})")
+
+
+# ── Tests: Worksheet ───────────────────────────────────────────────────────
+
+class TestWorksheet:
+
+    def test_10_get_or_create_worksheet(self, session, state):
+        """Ensure test worksheet exists (create if needed)."""
+        section_id = _get_or_create_section(session, state)
+        ws_id = _get_or_create_worksheet(session, state, section_id)
+        assert ws_id
+        print(f"\n  Worksheet ready: {ws_id}")
+
+    def _fetch_and_store_controls(self, session, state) -> list[dict]:
+        """Fetch controls from server and store full details in state.
+
+        Deduplicates by controlName, keeping the first occurrence of each name.
+        """
+        ws_id = state["worksheet_id"]
+        controls = ws_mod.get_worksheet_controls(session, ws_id)
+
+        seen_names: set[str] = set()
+        deduplicated = []
+        for c in controls:
+            cid = c.get("controlId")
+            name = c.get("controlName", "")
+            if not cid:
+                continue
+            if name in seen_names:
+                continue  # skip duplicate field names
+            seen_names.add(name)
+            deduplicated.append({
+                "controlId": cid,
+                "name": name,
+                "type": c.get("type", 2),
+                "dot": c.get("dot", 0),
+                "options": c.get("options", []),
+                "attribute": c.get("attribute", 0),
+            })
+
+        state["controls"] = deduplicated
+        _save_state(state)
+        return deduplicated
+
+    def test_11_add_controls(self, session, state):
+        """Add TEXT, NUMBER, DROP_DOWN fields if not already present."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        # Check what already exists on the server
+        existing = ws_mod.get_worksheet_controls(session, ws_id)
+        existing_names = {c.get("controlName") for c in existing}
+        needed = {"Name", "Amount", "Status"}
+        if needed.issubset(existing_names):
+            print(f"\n  Controls already exist — skipping creation")
+            self._fetch_and_store_controls(session, state)
+            return
+
+        controls = [
+            {"controlName": "Name", "type": ws_mod.FIELD_TYPES["TEXT"]},
+            {"controlName": "Amount", "type": ws_mod.FIELD_TYPES["NUMBER"]},
+            {
+                "controlName": "Status",
+                "type": ws_mod.FIELD_TYPES["DROP_DOWN"],
+                "options": [
+                    {"key": "opt1", "value": "Pending", "color": "#2196f3"},
+                    {"key": "opt2", "value": "Done", "color": "#4caf50"},
+                ],
+            },
+        ]
+        result = ws_mod.add_controls(session, ws_id, controls)
+        print(f"\n  add_controls raw result: {result}")
+
+        # Always fetch from server after adding to get full details with types
+        self._fetch_and_store_controls(session, state)
+        print(f"  Stored {len(state['controls'])} controls with full metadata")
+
+    def test_12_get_worksheet_info(self, session, state):
+        """Retrieve worksheet info and print controls."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        info = ws_mod.get_worksheet_info(session, ws_id, app_id=APP_ID, get_views=True)
+        assert info, f"get_worksheet_info returned empty"
+
+        # Use GetWorksheetControls for accurate control list
+        controls_full = self._fetch_and_store_controls(session, state)
+        print(f"\n  Controls ({len(controls_full)}): "
+              f"{[c.get('name') for c in controls_full]}")
+
+    def test_13_update_worksheet_desc(self, session, state):
+        """Update the worksheet description."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        result = ws_mod.update_worksheet(
+            session, ws_id,
+            desc="Created by integration test — safe to delete",
+            app_id=APP_ID,
+        )
+        print(f"\n  update_worksheet_desc: {result}")
+
+
+# ── Tests: Views ───────────────────────────────────────────────────────────
+
+class TestView:
+
+    def test_20_create_grid_view(self, session, state):
+        """Create a grid view (viewType=0)."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        result = ws_mod.save_view(
+            session, worksheet_id=ws_id,
+            name="Integration Grid View", view_type=0, app_id=APP_ID,
+        )
+        assert result, f"save_view returned empty: {result}"
+        view_id = result.get("viewId") if isinstance(result, dict) else None
+        assert view_id, f"No viewId in: {result}"
+        state["view_id"] = view_id
+        _save_state(state)
+        print(f"\n  Created grid view: {view_id}")
+
+    def test_21_create_gallery_view(self, session, state):
+        """Create a gallery view (viewType=2)."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        result = ws_mod.save_view(
+            session, worksheet_id=ws_id,
+            name="Integration Gallery View", view_type=2, app_id=APP_ID,
+        )
+        assert result, f"save_view returned empty: {result}"
+        view_id = result.get("viewId") if isinstance(result, dict) else None
+        state["gallery_view_id"] = view_id
+        _save_state(state)
+        print(f"\n  Created gallery view: {view_id}")
+
+    def test_22_list_views(self, session, state):
+        """List views and verify at least 2 exist."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        views = ws_mod.get_worksheet_views(session, ws_id, app_id=APP_ID)
+        assert isinstance(views, list), f"Expected list, got: {type(views)}"
+        print(f"\n  Views ({len(views)}):")
+        for v in views:
+            print(f"    - {v.get('name')}  type={v.get('viewType')}  id={v.get('viewId')}")
+        assert len(views) >= 2, f"Expected ≥ 2 views, got {len(views)}"
+
+    def test_23_delete_gallery_view(self, session, state):
+        """Delete the gallery view."""
+        ws_id = state.get("worksheet_id")
+        gvid = state.get("gallery_view_id")
+        if not gvid:
+            pytest.skip("gallery_view_id not set")
+
+        result = ws_mod.delete_view(session, ws_id, gvid, app_id=APP_ID)
+        print(f"\n  delete_view: {result}")
+        state.pop("gallery_view_id", None)
+        _save_state(state)
+
+
+# ── Tests: Business Rules ──────────────────────────────────────────────────
+
+class TestBusinessRule:
+
+    def _field_meta(self, session, state, name: str) -> dict | None:
+        """Return full control metadata dict for field with given name."""
+        for c in state.get("controls", []):
+            if c.get("name") == name:
+                return c
+        # fallback: fetch from server
+        ws_id = state.get("worksheet_id")
+        if ws_id:
+            controls = ws_mod.get_worksheet_controls(session, ws_id)
+            for c in controls:
+                if c.get("controlName") == name:
+                    return {
+                        "controlId": c["controlId"],
+                        "name": c.get("controlName", ""),
+                        "type": c.get("type", 2),
+                        "dot": c.get("dot", 0),
+                        "options": c.get("options", []),
+                    }
+        return None
+
+    def test_30_get_control_rules(self, session, state):
+        """Retrieve existing control rules."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        result = ws_mod.get_control_rules(session, ws_id)
+        print(f"\n  get_control_rules: {result}")
+
+    def test_31_save_control_rule(self, session, state):
+        """Save a visibility rule: show Amount only when Status=Pending."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        amount_meta = self._field_meta(session, state, "Amount")
+        status_meta = self._field_meta(session, state, "Status")
+
+        if not amount_meta or not status_meta:
+            pytest.skip("Could not resolve Amount/Status control metadata")
+
+        # Get the first option key of Status for the filter value
+        status_opts = status_meta.get("options", [])
+        pending_key = status_opts[0].get("key", "opt1") if status_opts else "opt1"
+
+        rule = {
+            "ruleId": "",
+            "ruleName": "Show Amount when Pending",
+            "disabled": False,
+            "type": 1,
+            "filters": [{
+                "controlId": status_meta["controlId"],
+                "dataType": status_meta["type"],
+                "spliceType": 1,
+                "filterType": 2,
+                "values": [pending_key],
+            }],
+            "actions": [{"type": 1, "controlIds": [amount_meta["controlId"]]}],
+        }
+        result = ws_mod.save_control_rule(session, ws_id, [rule])
+        print(f"\n  save_control_rule: {result}")
+
+
+# ── Tests: Custom Buttons ──────────────────────────────────────────────────
+
+class TestCustomButton:
+
+    def test_40_get_buttons(self, session, state):
+        """List existing custom buttons."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        result = ws_mod.get_buttons(session, ws_id)
+        print(f"\n  get_buttons: {result}")
+
+    def test_41_create_button(self, session, state):
+        """Create a custom action button (auto-creates a linked workflow)."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        # Payload per SaveWorksheetBtn API spec
+        btn_data = {
+            "btnId": "",
+            "name": "Integration Test Button",
+            "filters": [],
+            "confirmMsg": "确认执行此操作吗？",
+            "sureName": "确认",
+            "cancelName": "取消",
+            "workflowId": "",
+            "desc": "",
+            "appId": APP_ID,
+            "isAllView": 1,
+            "color": "#2196f3ff",
+            "icon": "send_8",
+            "writeControls": [],
+            "addRelationControlId": "",
+            "relationControl": "",
+            "writeType": "",
+            "writeObject": "",
+            "clickType": 1,
+            "showType": 1,
+            "advancedSetting": {
+                "remarkrequired": "0",
+                "remarkname": "",
+                "tiptext": "",
+            },
+            "workflowType": 1,
+        }
+        result = ws_mod.save_button(session, ws_id, btn_data)
+        print(f"\n  create button result: {result}")
+        assert result is not None, f"save_button returned None"
+
+        # Response: {"data": "<triggerId>", "state": 1}
+        # 'data' is the triggerId of the auto-created workflow
+        trigger_id = result if isinstance(result, str) else (
+            result.get("data") or result.get("btnId") or result.get("id")
+        )
+        if trigger_id:
+            state["button_id"] = trigger_id  # triggerId doubles as button ID
+            _save_state(state)
+            print(f"  triggerId (button_id): {trigger_id}")
+
+            # Immediately discover the linked workflow process ID
+            import requests as _req
+            _headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"md_pss_id {session.auth_token}",
+                "X-Requested-With": "XMLHttpRequest",
+            }
+            _url = (
+                f"https://api.mingdao.com/workflow/process/getProcessByTriggerId"
+                f"?appId={ws_id}&triggerId={trigger_id}"
+            )
+            _r = _req.get(_url, headers=_headers, timeout=30)
+            if _r.status_code == 200:
+                _resp = _r.json()
+                # Response: {"status": 1, "data": [{id, name, flowNodes, ...}]}
+                _inner = _resp.get("data", _resp)
+                if isinstance(_inner, list) and _inner:
+                    pid = _inner[0].get("id") or _inner[0].get("processId")
+                elif isinstance(_inner, dict):
+                    pid = _inner.get("id") or _inner.get("processId")
+                else:
+                    pid = None
+                if pid:
+                    state["process_id"] = pid
+                    _save_state(state)
+                    print(f"  Auto-discovered process_id: {pid}")
+                else:
+                    print(f"  getProcessByTriggerId: could not extract process_id")
+
+    def test_42_delete_button(self, session, state):
+        """Delete the button created above."""
+        ws_id = state.get("worksheet_id")
+        btn_id = state.get("button_id")
+        if not btn_id:
+            pytest.skip("button_id not set")
+
+        result = ws_mod.delete_button(session, ws_id, btn_id)
+        print(f"\n  delete button: {result}")
+        state.pop("button_id", None)
+        _save_state(state)
+
+
+# ── Tests: Records ─────────────────────────────────────────────────────────
+
+class TestRecord:
+
+    def _name_control_meta(self, session, state) -> dict | None:
+        """Return the full control object for the 'Name' field."""
+        for c in state.get("controls", []):
+            if c.get("name") == "Name":
+                return c
+        # Fallback: fetch from server
+        ws_id = state.get("worksheet_id")
+        if ws_id:
+            controls = ws_mod.get_worksheet_controls(session, ws_id)
+            for c in controls:
+                if c.get("controlName") == "Name":
+                    return {
+                        "controlId": c["controlId"],
+                        "name": c.get("controlName", ""),
+                        "type": c.get("type", 2),
+                        "dot": c.get("dot", 0),
+                    }
+        return None
+
+    def _build_receive_control(self, meta: dict, value: str) -> dict:
+        """Build a receiveControl item with required fields for AddWorksheetRow."""
+        return {
+            "controlId": meta["controlId"],
+            "type": meta["type"],
+            "value": value,
+            "controlName": meta["name"],
+            "dot": meta.get("dot", 0),
+        }
+
+    def test_50_create_record(self, session, state):
+        """Create a record in the test worksheet."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        name_meta = self._name_control_meta(session, state)
+        controls = (
+            [self._build_receive_control(name_meta, "Alpha Record")]
+            if name_meta else []
+        )
+
+        result = rec_mod.create_record(
+            session, worksheet_id=ws_id, controls=controls, trigger_workflow=False,
+        )
+        assert result, f"create_record returned empty: {result}"
+
+        # Response: {resultCode, data: {_id, rowid, ...}}
+        if isinstance(result, str):
+            row_id = result
+        else:
+            inner = result.get("data") if isinstance(result, dict) else None
+            row_id = (
+                (inner.get("rowid") or inner.get("_id") or inner.get("rowId"))
+                if isinstance(inner, dict)
+                else (result.get("rowId") or result.get("id") or result.get("rowid"))
+            )
+        assert row_id, f"Could not extract rowId from: {result}"
+        state["row_id"] = row_id
+        _save_state(state)
+        print(f"\n  Created record: {row_id}")
+
+    def test_51_get_record(self, session, state):
+        """Retrieve the created record."""
+        ws_id = state.get("worksheet_id")
+        row_id = state.get("row_id")
+        assert ws_id and row_id, "worksheet_id or row_id not set"
+
+        result = rec_mod.get_record(session, ws_id, row_id)
+        assert result, f"get_record returned empty"
+        print(f"\n  Record keys: {list(result.keys()) if isinstance(result, dict) else type(result)}")
+
+    def test_52_update_record(self, session, state):
+        """Update the record's Name field."""
+        ws_id = state.get("worksheet_id")
+        row_id = state.get("row_id")
+        assert ws_id and row_id, "worksheet_id or row_id not set"
+
+        name_meta = self._name_control_meta(session, state)
+        controls = (
+            [self._build_receive_control(name_meta, "Alpha Record (updated)")]
+            if name_meta else []
+        )
+        result = rec_mod.update_record(
+            session, worksheet_id=ws_id, row_id=row_id,
+            controls=controls, trigger_workflow=False,
+        )
+        print(f"\n  update_record: {result}")
+
+    def test_53_list_records(self, session, state):
+        """List records from the worksheet."""
+        ws_id = state.get("worksheet_id")
+        assert ws_id, "worksheet_id not set"
+
+        result = rec_mod.get_records(session, ws_id, page_size=20)
+        assert isinstance(result, dict)
+        records = result.get("data", [])
+        print(f"\n  Records: count={result.get('count', '?')}, page={len(records)}")
+        assert len(records) >= 1
+
+    def test_54_delete_record(self, session, state):
+        """Delete the created record."""
+        ws_id = state.get("worksheet_id")
+        row_id = state.get("row_id")
+        assert ws_id and row_id, "worksheet_id or row_id not set"
+
+        result = rec_mod.delete_records(session, ws_id, [row_id])
+        print(f"\n  delete_records: {result}")
+        state.pop("row_id", None)
+        state.pop("name_control_id", None)
+        _save_state(state)
+
+
+# ── Tests: Workflow ────────────────────────────────────────────────────────
+
+
+class TestWorkflow:
+    """Tests for the workflow auto-created by the custom action button.
+
+    When a button is saved via SaveWorksheetBtn, the API auto-creates a linked
+    workflow. We discover that workflow via getProcessByTriggerId and verify it.
+    """
+
+    def _get_process_id_from_trigger(self, session, state) -> str | None:
+        """GET /workflow/process/getProcessByTriggerId to discover processId."""
+        trigger_id = state.get("button_id")
+        ws_id = state.get("worksheet_id")
+        if not trigger_id or not ws_id:
+            return None
+        import requests
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"md_pss_id {session.auth_token}",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+        url = (
+            f"https://api.mingdao.com/workflow/process/getProcessByTriggerId"
+            f"?appId={ws_id}&triggerId={trigger_id}"
+        )
+        r = requests.get(url, headers=headers, timeout=30)
+        if r.status_code == 200:
+            data = r.json()
+            return data.get("processId") or data.get("id")
+        print(f"  getProcessByTriggerId: HTTP {r.status_code}  {r.text[:200]}")
+        return None
+
+    def test_60_verify_workflow_discovered(self, session, state):
+        """Verify the workflow process_id was discovered when button was created."""
+        pid = state.get("process_id")
+        if not pid:
+            # Try to re-discover from button_id if it still exists
+            if state.get("button_id"):
+                pid = self._get_process_id_from_trigger(session, state)
+                if pid:
+                    state["process_id"] = pid
+                    _save_state(state)
+
+        assert pid, (
+            "process_id not set — button creation in test_41 should have "
+            "auto-discovered it via getProcessByTriggerId"
+        )
+        print(f"\n  Workflow process_id: {pid}")
+
+    def test_61_get_process_info(self, session, state):
+        """Retrieve process info via GET getProcessById."""
+        pid = state.get("process_id")
+        if not pid:
+            pytest.skip("process_id not discovered")
+
+        import requests
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"md_pss_id {session.auth_token}",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+        url = (
+            f"https://api.mingdao.com/workflow/process/getProcessById"
+            f"?processId={pid}"
+        )
+        r = requests.get(url, headers=headers, timeout=30)
+        print(f"\n  GET getProcessById: HTTP {r.status_code}")
+        if r.status_code == 200:
+            data = r.json()
+            print(f"  Process: name={data.get('name')}  enabled={data.get('enabled')}")
+        else:
+            print(f"  Response: {r.text[:200]}")
+
+    def test_62_get_nodes(self, session, state):
+        """Retrieve nodes for the workflow via GET flowNode/get."""
+        pid = state.get("process_id")
+        if not pid:
+            pytest.skip("process_id not set")
+
+        import requests
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"md_pss_id {session.auth_token}",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+        url = f"https://api.mingdao.com/workflow/flowNode/get?processId={pid}"
+        r = requests.get(url, headers=headers, timeout=30)
+        print(f"\n  GET flowNode/get: HTTP {r.status_code}")
+        if r.status_code == 200:
+            data = r.json()
+            if isinstance(data, list):
+                print(f"  Node count: {len(data)}")
+                for n in data:
+                    print(f"    {n.get('name')}  type={n.get('flowNodeType')}")
+            elif isinstance(data, dict):
+                print(f"  Keys: {list(data.keys())}")
+        else:
+            print(f"  Response: {r.text[:200]}")
+
+    def test_63_list_workflows(self, session, state):
+        """List workflows in the app (informational)."""
+        try:
+            result = wf_mod.get_process_list(session, relation_id=APP_ID)
+            processes = result.get("data", [])
+            print(f"\n  Workflows in app: count={result.get('count', '?')}")
+            for p in processes[:5]:
+                print(f"    {p.get('name')}  id={p.get('processId') or p.get('id')}")
+        except Exception as e:
+            print(f"\n  get_process_list error (non-fatal): {e}")
+
+
+# ── Tests: Cleanup ─────────────────────────────────────────────────────────
+
+class TestCleanup:
+
+    def test_99_cleanup_transient(self, session, state):
+        """Delete transient resources (workflow, test views); keep worksheet."""
+        print("\n  Cleaning transient resources...")
+
+        # Delete grid view if it still exists
+        ws_id = state.get("worksheet_id")
+        if ws_id and (vid := state.get("view_id")):
+            try:
+                ws_mod.delete_view(session, ws_id, vid, app_id=APP_ID)
+                print(f"  Deleted view {vid}")
+            except Exception as e:
+                print(f"  Could not delete view: {e}")
+
+        # Delete gallery view if still present
+        if ws_id and (gvid := state.get("gallery_view_id")):
+            try:
+                ws_mod.delete_view(session, ws_id, gvid, app_id=APP_ID)
+                print(f"  Deleted gallery view {gvid}")
+            except Exception as e:
+                print(f"  Could not delete gallery view: {e}")
+
+        # Delete remaining record if any
+        if ws_id and (rid := state.get("row_id")):
+            try:
+                rec_mod.delete_records(session, ws_id, [rid])
+                print(f"  Deleted record {rid}")
+            except Exception as e:
+                print(f"  Could not delete record: {e}")
+
+        # Delete workflow
+        _cleanup_transient(session, state)
+
+        print(f"  Persistent state retained: {list(state.keys())}")
+        print("  Done. Worksheet and section are preserved for the next run.")