@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/test/test_report_entity_integrity.py

@@ -12,9 +12,15 @@ as setReportFilters.
 These tests pin the fail-closed guard: the CLI refuses before touching the platform.
 """
 
+import copy
+import io
+import json
 import os
 import sys
+import tempfile
+import urllib.error
 import unittest
+from pathlib import Path
 from unittest import mock
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -74,8 +80,6 @@ class ReportEntityGuardTest(unittest.TestCase):
         for label, action in (
             ("filters", lambda: report_ops.set_report_filters(
                 {}, None, "FID", FILTERS, form_number="kdtest_rpt")),
-            ("sorts", lambda: report_ops.set_report_sorts(
-                {}, None, "FID", SORTS, form_number="kdtest_rpt")),
             ("plugin", lambda: report_ops.register_report_plugin(
                 {}, None, "FID", PLUGIN, form_number="kdtest_rpt")),
         ):
@@ -83,6 +87,13 @@ class ReportEntityGuardTest(unittest.TestCase):
             self.assertIsNone(error, f"{label}: {error}")
             self.assertEqual(1, writes, label)
 
+    def test_sorts_are_refused_even_when_the_entity_is_healthy(self):
+        for fields in (["sup_number", "sup_name"], ["sup_number", "sup_number"]):
+            error, writes = self._run(fields, lambda: report_ops.set_report_sorts(
+                {}, None, "FID", SORTS, form_number="kdtest_rpt"))
+            self.assertIn("REPORT_SORTS_API_UNSAFE", str(error))
+            self.assertEqual(writes, 0)
+
     # ── second column write: refuse before corrupting ───────────────────────
     def test_second_column_write_is_refused_without_touching_the_platform(self):
         error, writes = self._run(
@@ -107,6 +118,7 @@ class ReportEntityGuardTest(unittest.TestCase):
                 {}, None, "FID", COLUMNS, form_number="kdtest_rpt"))
         message = str(error)
         self.assertIn("addReportColumns", message)
+        self.assertIn("removeReportColumn", message)
         self.assertIn("planReportRecreate", message)
         self.assertIn("Do not add the column in the designer", message)
 
@@ -132,8 +144,6 @@ class ReportEntityGuardTest(unittest.TestCase):
                 {}, None, "FID", COLUMNS, form_number="kdtest_rpt")),
             ("filters", lambda: report_ops.set_report_filters(
                 {}, None, "FID", FILTERS, form_number="kdtest_rpt")),
-            ("sorts", lambda: report_ops.set_report_sorts(
-                {}, None, "FID", SORTS, form_number="kdtest_rpt")),
             ("plugin", lambda: report_ops.register_report_plugin(
                 {}, None, "FID", PLUGIN, form_number="kdtest_rpt")),
         ):
@@ -282,5 +292,270 @@ class ReportWriteFailureHonestyTest(unittest.TestCase):
         self.assertIn("setReportColumns failed: boom", str(ctx.exception))
 
 
+class ReportColumnRemovalTest(unittest.TestCase):
+    """真实删除契约和旧后端失败边界共用同一实现，不调用线上接口。"""
+
+    def column(self, key):
+        return {"kind": "column", "fieldKey": key, "dateIndex": key,
+                "fieldType": "text", "caption": key}
+
+    def schema(self, columns):
+        return {"formNumber": "kdtest_rpt", "reportColumns": columns,
+                "reportFilters": [], "reportSorts": [{"fieldKey": "keep", "direction": "asc"}],
+                "reportPlugins": [], "readBackAvailable": True, "readBackSource": "canonical"}
+
+    def receipt(self, key="drop"):
+        return {"status": True, "errorCode": "0", "data": {"success": True, "errorCode": "0",
+                "data": {"fieldKey": key, "fieldId": "FIELD", "action": "removed"}}}
+
+    def failed(self, message, code="META_SAVE_FAIL"):
+        return {"status": False, "errorCode": "META_SAVE_FAIL", "message": message,
+                "data": {"success": False, "errorCode": code, "message": message}}
+
+    def run_removal(self, root, response=None, after=None):
+        import cosmic_api
+        before = self.schema([self.column("drop"), self.column("keep")])
+        projection = after if after is not None else self.schema([self.column("keep")])
+        calls = []
+        def api(cfg, token, command, payload, method="GET"):
+            calls.append((command, payload, method))
+            if method == "POST":
+                if isinstance(response, Exception):
+                    raise response
+                return response if response is not None else self.receipt()
+            if any(call[2] == "POST" for call in calls):
+                if isinstance(projection, Exception):
+                    raise projection
+                return {"data": {"formNumber": "kdtest_rpt", "reportSchema": projection}}
+            return {"data": {"formNumber": "kdtest_rpt", "reportSchema": before}}
+        with mock.patch.object(report_ops, "_api_call", side_effect=api), \
+                mock.patch.object(cosmic_api, "_resolve_owned_report_target", return_value={"formId": "FID"}):
+            result = cosmic_api._dispatch_serve({}, "fixture", "removeReportColumn",
+                {"appRoot": root, "formNumber": "kdtest_rpt", "fieldKey": "drop"})
+        return result, calls
+
+    def baseline(self, root):
+        before = self.schema([self.column("drop"), self.column("keep")])
+        artifact = {"reportColumns": copy.deepcopy(before["reportColumns"]),
+                    "reportSorts": [{"fieldKey": "drop", "direction": "desc"}, *before["reportSorts"]],
+                    "reportFilters": [{"fieldPath": "flt_drop", "displayName": "Drop", "compare": "="}],
+                    "reportPlugins": [{"className": "kd.example.report.Query", "type": "Java"}],
+                    "reportProperties": {"columns": {"drop": {"Width": "80"}, "keep": {"Width": "100"}}}}
+        artifact["reportColumns"][1]["presentation"] = {"kind": "basedata", "entityId": "bos_user", "displayProp": "name"}
+        report_ops.write_report_authoring_state(root, "kdtest_rpt", "FID", artifact, before)
+        return artifact, before
+
+    def test_success_is_one_real_remove_post_with_independent_readback(self):
+        with tempfile.TemporaryDirectory() as root:
+            result, calls = self.run_removal(root)
+        self.assertTrue(result["status"])
+        self.assertTrue(result["verification"]["verified"])
+        self.assertTrue(result["data"]["platformMutationApplied"])
+        self.assertFalse(result["data"]["runtimeVerified"])
+        self.assertFalse(result["verification"]["entityFieldCleanup"]["verified"])
+        self.assertEqual(result["data"]["reportAuthoringState"]["status"], "incomplete")
+        writes = [call for call in calls if call[2] == "POST"]
+        self.assertEqual(writes, [("setComplexProperty", {"formNumber": "kdtest_rpt",
+            "complexType": "ReportColumns.remove", "data": {"fieldKey": "drop"}}, "POST")])
+        self.assertEqual(calls[-1][0], "getFormSchema")
+
+    def test_old_branch_and_http_route_preserve_complete_baseline(self):
+        from _core.execution_errors import attach_execution_error
+        responses = [self.failed("不支持的复杂属性类型: ReportColumns.remove。"),
+                     self.failed("Unsupported complex property type: ReportColumns.remove."),
+                     {"status": False, "errorCode": "404", "message": "cannot found openapi"},
+                     *[urllib.error.HTTPError("https://example.invalid/setComplexProperty", code,
+                         "Missing route", {}, io.BytesIO(b"not found")) for code in (404, 405, 501)]]
+        for response in responses:
+            with self.subTest(response=response), tempfile.TemporaryDirectory() as root:
+                self.baseline(root)
+                path = report_ops.report_authoring_path(root, "kdtest_rpt")
+                original = path.read_bytes()
+                result, calls = self.run_removal(root, response)
+                self.assertEqual(path.read_bytes(), original)
+                self.assertFalse(result["status"])
+                self.assertEqual(result["errorCode"], "REPORT_COLUMN_DELETE_API_UNAVAILABLE")
+                categorized = attach_execution_error(result)
+                self.assertEqual(categorized["errorCategory"], "capability_limit")
+                self.assertTrue(categorized["capabilityLimitConfirmed"])
+                self.assertFalse(result["data"]["platformMutationApplied"])
+                self.assertNotIn("platformMutationPossible", result["data"])
+                self.assertEqual(sum(call[2] == "POST" for call in calls), 1)
+                self.assertNotIn("reportAuthoringState", result["data"])
+
+    def test_save_permission_and_transient_failures_are_not_capability_missing(self):
+        responses = [self.failed("save rejected"), self.failed("permission denied", "403"),
+                     self.failed("NullPointerException"), {"status": False, "errorCode": "404", "message": "column not found"},
+                     TimeoutError("gateway"), urllib.error.HTTPError("https://example.invalid", 503, "Unavailable", {}, None)]
+        for response in responses:
+            with self.subTest(response=response), tempfile.TemporaryDirectory() as root:
+                self.baseline(root)
+                result, calls = self.run_removal(root, response)
+                self.assertFalse(result["status"])
+                self.assertNotEqual(result["errorCode"], "REPORT_COLUMN_DELETE_API_UNAVAILABLE")
+                self.assertTrue(result["data"]["platformMutationPossible"])
+                self.assertNotIn("platformMutationApplied", result["data"])
+                state = json.loads(report_ops.report_authoring_path(root, "kdtest_rpt").read_text())
+                self.assertEqual(state["status"], "incomplete")
+                self.assertEqual(sum(call[2] == "POST" for call in calls), 1)
+
+    def test_conflicting_wrappers_and_http_bodies_do_not_mask_failures(self):
+        unsupported = "不支持的复杂属性类型: ReportColumns.remove。"
+        conflict = {**self.failed("save rejected"), "message": unsupported}
+        success_error = self.receipt()
+        success_error["data"]["errorCode"] = "META_SAVE_FAIL"
+        broken_body = mock.Mock()
+        broken_body.read.side_effect = OSError("body unavailable")
+        responses = [conflict, success_error,
+                     {**self.failed(unsupported, "403"), "message": unsupported},
+                     urllib.error.HTTPError("https://example.invalid", 404, "Not Found", {},
+                         io.BytesIO(json.dumps(self.failed("save rejected")).encode())),
+                     urllib.error.HTTPError("https://example.invalid", 404, "Not Found", {},
+                         io.BytesIO(json.dumps(self.receipt()).encode())),
+                     urllib.error.HTTPError("https://example.invalid", 404, "Not Found", {}, broken_body)]
+        for response in responses:
+            with self.subTest(response=response), tempfile.TemporaryDirectory() as root:
+                result, calls = self.run_removal(root, response)
+                self.assertFalse(result["status"])
+                self.assertNotEqual(result["errorCode"], "REPORT_COLUMN_DELETE_API_UNAVAILABLE")
+                self.assertTrue(result["data"]["platformMutationPossible"])
+                self.assertEqual(sum(call[2] == "POST" for call in calls), 1)
+
+    def test_explicit_business_rejection_is_not_capability_missing_or_mutation(self):
+        for code in ("PARAM_INVALID", "PROPERTY_ELEMENT_NOT_FOUND", "ELEMENT_NOT_FOUND"):
+            with self.subTest(code=code), tempfile.TemporaryDirectory() as root:
+                self.baseline(root)
+                with self.assertRaisesRegex(RuntimeError, "REPORT_COLUMN_DELETE_REJECTED") as error:
+                    self.run_removal(root, self.failed("target rejected", code))
+                self.assertNotIsInstance(error.exception, report_ops.ReportMutationError)
+                self.assertEqual(json.loads(report_ops.report_authoring_path(root, "kdtest_rpt").read_text())["status"], "current")
+
+    def test_success_receipt_followed_by_bad_readback_invalidates_without_replay(self):
+        for after in (TimeoutError("read failed"), {}, self.schema([self.column("drop"), self.column("keep")]),
+                      self.schema([self.column("other")])):
+            with self.subTest(after=after), tempfile.TemporaryDirectory() as root:
+                self.baseline(root)
+                result, calls = self.run_removal(root, after=after)
+                self.assertFalse(result["status"])
+                self.assertTrue(result["data"]["platformMutationApplied"])
+                self.assertFalse(result["verification"]["verified"])
+                self.assertEqual(result["data"]["reportAuthoringState"]["status"], "incomplete")
+                self.assertEqual(sum(call[2] == "POST" for call in calls), 1)
+
+    def test_canonical_missing_sections_are_not_empty_state_evidence(self):
+        before = self.schema([self.column("drop"), self.column("keep")])
+        expected = report_ops.plan_report_column_removal(before, "drop")
+        for missing in ("reportColumns", "reportFilters", "reportSorts", "reportPlugins"):
+            with self.subTest(missing=missing):
+                canonical = self.schema([self.column("keep")])
+                canonical.pop(missing)
+                with mock.patch.object(report_ops, "_get_schema", return_value={
+                        "data": {"formNumber": "kdtest_rpt", "reportSchema": canonical}}):
+                    after = report_ops.get_report_schema({}, None, "FID")
+                self.assertIn(missing, after["unverifiableSections"])
+                result = report_ops.report_readback_verification("columnsRemove", expected, after)
+                if missing == "reportColumns":
+                    self.assertFalse(result["verified"])
+                    with self.assertRaisesRegex(ValueError, "REPORT_READBACK_UNAVAILABLE"):
+                        report_ops.plan_report_column_removal(after, "drop")
+                else:
+                    self.assertTrue(result["verified"])
+                    self.assertIn(missing, result["unverifiedProperties"])
+        with tempfile.TemporaryDirectory() as root:
+            result, calls = self.run_removal(root, after={"readBackAvailable": True})
+        self.assertFalse(result["status"])
+        self.assertTrue(result["data"]["platformMutationApplied"])
+        self.assertEqual(sum(call[2] == "POST" for call in calls), 1)
+
+    def test_wrong_receipt_is_applied_evidence_not_verified_deletion(self):
+        with tempfile.TemporaryDirectory() as root:
+            result, calls = self.run_removal(root, self.receipt("other"))
+        self.assertFalse(result["status"])
+        self.assertEqual(result["errorCode"], "REPORT_COLUMN_DELETE_RECEIPT_INVALID")
+        self.assertTrue(result["data"]["platformMutationApplied"])
+        self.assertEqual(sum(call[2] == "POST" for call in calls), 1)
+
+    def test_nested_leaf_preserves_parent_sibling_order_and_other_properties(self):
+        before = self.schema([{"kind": "group", "fieldKey": "group", "caption": "Group", "children": [
+            {**self.column("drop"), "index": 0}, {**self.column("keep"), "index": 1, "width": "120"}]}])
+        after = copy.deepcopy(before)
+        after["reportColumns"][0]["children"].pop(0)
+        after["reportColumns"][0]["children"][0]["index"] = 0
+        expected = report_ops.plan_report_column_removal(before, "drop")
+        self.assertTrue(report_ops.report_readback_verification("columnsRemove", expected, after)["verified"])
+        after["reportColumns"][0]["children"][0]["width"] = "80"
+        self.assertFalse(report_ops.report_readback_verification("columnsRemove", expected, after)["verified"])
+
+    def test_sort_cleanup_is_verified_when_observable_and_not_invented_when_missing(self):
+        before = self.schema([self.column("drop"), self.column("keep")])
+        before["reportSorts"].append({"fieldKey": "drop", "direction": "desc"})
+        expected = report_ops.plan_report_column_removal(before, "drop")
+        after = self.schema([self.column("keep")])
+        self.assertTrue(report_ops.report_readback_verification("columnsRemove", expected, after)["verified"])
+        after["reportSorts"] = before["reportSorts"]
+        self.assertFalse(report_ops.report_readback_verification("columnsRemove", expected, after)["verified"])
+        after["unverifiableSections"] = ["reportSorts"]
+        result = report_ops.report_readback_verification("columnsRemove", expected, after)
+        self.assertTrue(result["verified"])
+        self.assertIn("reportSorts", result["unverifiedProperties"])
+
+    def test_absent_group_ambiguous_and_malformed_targets_fail_before_write(self):
+        schemas = [self.schema([self.column("keep")]), self.schema([{"kind": "group", "fieldKey": "drop", "children": []}]),
+                   self.schema([self.column("drop"), self.column("drop")]), self.schema([None]), {"readBackAvailable": False},
+                                      {**self.schema([self.column("drop")]), "formNumber": "another_report"}]
+        for schema in schemas:
+            with self.subTest(schema=schema), mock.patch.object(report_ops, "_api_call") as api:
+                with self.assertRaises(ValueError):
+                    report_ops.plan_report_column_removal(schema, "drop", form_number="kdtest_rpt")
+                api.assert_not_called()
+
+    def test_authoring_withdraws_only_deleted_column_sort_and_properties(self):
+        with tempfile.TemporaryDirectory() as root:
+            artifact, before = self.baseline(root)
+            after = self.schema([self.column("keep")])
+            result = report_ops.sync_report_authoring_state(root, "kdtest_rpt", "FID", "columnsRemove",
+                {"fieldKey": "drop", "before": before}, before, after, {"verified": True})
+            compiled = json.loads(Path(result["contractPath"]).read_text(encoding="utf-8"))
+            current = json.loads(Path(result["artifactPath"]).read_text(encoding="utf-8"))
+        self.assertEqual(compiled["dataSetColumns"], ["keep"])
+        self.assertEqual(compiled["defaultSorts"], [{"fieldKey": "keep", "dateIndex": "keep", "direction": "asc"}])
+        self.assertFalse(compiled["defaultSortPolicy"]["runtimeVerified"])
+        self.assertEqual(current["reportSorts"], [{"fieldKey": "keep", "direction": "asc"}])
+        self.assertEqual(current["reportProperties"]["columns"], {"keep": {"Width": "100"}})
+        self.assertEqual(current["reportColumns"][0]["presentation"], artifact["reportColumns"][1]["presentation"])
+        self.assertEqual(current["reportFilters"], artifact["reportFilters"])
+        self.assertEqual(current["reportPlugins"], artifact["reportPlugins"])
+
+    def test_historical_precision_dependency_still_blocks_deletion(self):
+        with tempfile.TemporaryDirectory() as root:
+            artifact, before = self.baseline(root)
+            artifact["reportColumns"][0]["fieldType"] = "bigint"
+            artifact["reportColumns"][1]["fieldType"] = "decimal"
+            artifact["reportColumns"][1]["presentation"] = {"kind": "amount", "currencyField": "drop"}
+            with self.assertRaisesRegex(ValueError, "REPORT_PRECISION_REFERENCE_UNVERIFIED"):
+                report_ops.normalize_report_columns_input(artifact["reportColumns"])
+            # 模拟门禁上线前已存在的历史夹具；不调用当前 writer 将危险输入标成新成功状态。
+            path = report_ops.report_authoring_path(root, "kdtest_rpt")
+            historical = json.loads(path.read_text(encoding="utf-8"))
+            historical["artifact"] = artifact
+            path.write_text(json.dumps(historical), encoding="utf-8")
+            original = path.read_bytes()
+            with mock.patch.object(report_ops, "_api_call") as http:
+                with self.assertRaisesRegex(ValueError, "REPORT_COLUMN_IN_USE"):
+                    report_ops.plan_report_column_removal(before, "drop", root, "kdtest_rpt", "FID")
+                http.assert_not_called()
+            self.assertEqual(path.read_bytes(), original)
+
+    def test_empty_remaining_tree_or_group_cannot_become_current_artifact(self):
+        for columns in ([self.column("drop")], [{"kind": "group", "fieldKey": "g", "caption": "Group", "children": [self.column("drop")]}]):
+            with self.subTest(columns=columns), tempfile.TemporaryDirectory() as root:
+                before = self.schema(columns)
+                report_ops.write_report_authoring_state(root, "kdtest_rpt", "FID", {"reportColumns": columns}, before)
+                after = {**before, "reportColumns": report_ops._without_report_column(columns, "drop")}
+                result = report_ops.sync_report_authoring_state(root, "kdtest_rpt", "FID", "columnsRemove",
+                    {"fieldKey": "drop"}, before, after, {"verified": True})
+                self.assertEqual(result["status"], "incomplete")
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/test/test_report_field_guard.py

@@ -66,7 +66,7 @@ def _add_field(target, quick=None):
                              "fieldType": "TextField"},
         }
         result = cmd_formactions.do_add_field(
-            {}, None, "kdtest_ljbb_rpt", "Creator Email", "creator_email",
+            {}, None, "kdtest_ljbb_rpt", "Creator Email", "creator_email", "TextField",
             app_root="/tmp/kdtest_guaner",
         )
         return result, quickfield.call_count