@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

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

@@ -0,0 +1,382 @@
+import copy
+import json
+import subprocess
+import sys
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _core import cmd_listui, cmd_operations, cmd_properties
+
+
+@pytest.mark.parametrize("locale", ["", ".locales/zh"])
+def test_menu_contract_is_discoverable_without_local_application_files(tmp_path, locale):
+    root = Path(__file__).resolve().parents[4]
+    cli = root / locale / "skills/cosmic-meta-api/scripts/cosmic_api.py"
+    result = subprocess.run(
+        [sys.executable, str(cli), "--stdout", "describeCommand", "configureDropdownMenu"],
+        cwd=tmp_path, capture_output=True, text=True, check=True,
+    )
+    action = json.loads(result.stdout)["action"]
+    assert action["command"] == "configureDropdownMenu"
+    assert {"append", "update", "order"} <= set(action["payloadSchema"]["properties"])
+    flags = {flag for argument in action["arguments"] for flag in argument["flags"]}
+    assert {"--form-name", "--element", "--input", "--app-root"} <= flags
+
+
+# JavaBean projection used by getProperties, including LocaleString and derived values.
+CURRENT = [
+    {"id": "id-a", "key": "a", "title": {"zh_CN": "设置"},
+     "operationKey": "op_a", "visible": "init,new", "index": 1,
+     "visibleValue": 9, "isv": "uhyl"},
+    {"id": "id-b", "key": "b", "title": {"zh_CN": "预览"},
+     "operationKey": "op_b", "index": 2},
+]
+
+
+@pytest.fixture
+def platform(monkeypatch):
+    state = {"items": copy.deepcopy(CURRENT), "writes": [], "operations": 0}
+    def read(*args, **kwargs):
+        return {"status": True, "data": {"dropdownItems": json.dumps(state["items"])}}
+    def load(*args, **kwargs):
+        if state.get("saved_document") is not None:
+            return {"status": True, "data": copy.deepcopy(state["saved_document"])}
+        native, locale_rows = [], []
+        for row in state["items"]:
+            item = cmd_properties._dropdown_authored_item(row)
+            if "Isv" in item:
+                item["IsvFlag"] = item.pop("Isv")
+            for field in ("Title", "SubTitle"):
+                value = item.get(field)
+                if not isinstance(value, dict):
+                    continue
+                resource = f"app.form.button-id.DropdownItems.{item['Id']}.{field}"
+                locale_rows.append({resource: {"resId": resource, **value}})
+                item[field] = value.get("zh_CN") or next(iter(value.values()), "")
+            native.append(item)
+        return {"status": True, "data": {
+            "appNum": "app",
+            "formmeta": {"Key": "form", "Id": "form", "Language": "zh_CN", "IsvFlag": "uhyl",
+                         "Items": [{"Key": "print", "Id": "button-id", "DropdownItems": native}]},
+            "entitymeta": {"Key": "form", "IsvFlag": "uhyl", "Rules": [{"Id": "keep-rule"}]},
+            "localeItems": {"form": locale_rows},
+        }}
+    def save(cfg, token, form, payload, **kwargs):
+        state["saved_document"] = copy.deepcopy(payload)
+        items = payload["formmeta"]["Items"][0]["DropdownItems"]
+        assert payload["entitymeta"]["Rules"] == [{"Id": "keep-rule"}]
+        state["writes"].append(copy.deepcopy(items))
+        locales = {key: value for row in payload["localeItems"]["form"]
+                   for key, value in row.items()}
+        state["items"] = []
+        for item in items:
+            projected = {
+                key[:1].lower() + key[1:]: value
+                for key, value in cmd_properties._dropdown_authored_item(item).items()
+            }
+            for field in ("Title", "SubTitle"):
+                resource = next((value for key, value in locales.items()
+                                 if key.endswith(f".{item['Id']}.{field}")), None)
+                if resource:
+                    projected[field[:1].lower() + field[1:]] = {
+                        key: value for key, value in resource.items() if key != "resId"}
+            state["items"].append(projected)
+        return {"status": True, "data": {}}
+    def operations(*args, **kwargs):
+        state["operations"] += 1
+        return {"status": True, "data": [
+            {"operationKey": key, "operationType": "printpreview"}
+            for key in ("op_a", "op_b", "op_c")]}
+    monkeypatch.setattr(cmd_properties, "do_get_properties", read)
+    monkeypatch.setattr(cmd_listui, "do_load_full_metadata", load)
+    monkeypatch.setattr(cmd_listui, "do_save_full_metadata", save)
+    monkeypatch.setattr(cmd_properties, "do_get_property_schema", lambda *args: {
+        "status": True, "data": [{"propertyName": "DropdownItems", "editable": True}]})
+    monkeypatch.setattr(cmd_operations, "do_list_operations", operations)
+    return state
+
+
+def edit(intent):
+    return cmd_properties.do_configure_dropdown_menu({}, "", "form", "print", intent)
+
+
+def test_real_projection_combined_edit_is_one_save_and_preserves_ids(platform):
+    result = edit({
+        "update": [{"key": "设置", "subtitle": "打印配置"}],
+        "append": [{"key": "c", "title": "PDF", "operation": "op_c"}],
+        "moves": [{"key": "c", "before": "预览"}],
+    })
+    assert result["status"] is True
+    assert result["verification"]["verified"] is True
+    assert len(platform["writes"]) == 1
+    items = platform["writes"][0]
+    assert [item["Key"] for item in items] == ["a", "c", "b"]
+    assert items[0]["Id"] == "id-a"
+    assert items[2]["Id"] == "id-b"
+    assert items[0]["SubTitle"] == "打印配置"
+    assert items[2]["Title"] == "预览"
+    assert platform["items"][0]["isv"] == "uhyl"
+    assert platform["operations"] == 1
+
+
+def test_target_resolution_accepts_unique_operation_and_exact_key_wins(platform):
+    result = edit({"update": [{"key": "op_a", "title": "打印设置"}]})
+    assert result["status"] is True
+    assert platform["writes"][0][0]["Key"] == "a"
+    assert platform["operations"] == 0
+
+
+def test_expected_snapshot_includes_exact_locale_side_effects(platform):
+    platform["items"][0]["title"]["en_US"] = "Settings"
+    result = cmd_properties.do_configure_dropdown_menu({}, "", "form", "print", {
+        "update": [{"key": "a", "title": "打印参数设置", "subtitle": "选择参数和模板"}],
+    }, locale="zh_CN")
+    assert result["status"] is True
+    assert result["verification"]["verified"] is True
+    assert len(result["verification"]["changedLocalePaths"]) == 2
+    resources = platform["saved_document"]["localeItems"]["form"]
+    localized = {key: value for row in resources for key, value in row.items()}
+    title = next(value for key, value in localized.items() if key.endswith(".Title"))
+    subtitle = next(value for key, value in localized.items() if key.endswith(".SubTitle"))
+    assert title["zh_CN"] == "打印参数设置"
+    assert title["en_US"] == "Settings"
+    assert subtitle["zh_CN"] == "选择参数和模板"
+
+
+def test_new_item_gets_owned_locale_resources(platform):
+    result = edit({"append": [{"key": "new", "title": "新菜单", "subtitle": "说明"}]})
+    assert result["status"] is True
+    resources = platform["saved_document"]["localeItems"]["form"]
+    created = {key: value for row in resources for key, value in row.items()
+               if ".DropdownItems." in key and value.get("zh_CN") in ("新菜单", "说明")}
+    assert len(created) == 2
+    assert all(key == value["resId"] for key, value in created.items())
+
+
+def test_remove_keeps_unmentioned_item_and_avoids_operation_scan(platform):
+    result = edit({"remove": ["预览"]})
+    assert result["status"] is True
+    assert [item["Id"] for item in platform["writes"][0]] == ["id-a"]
+    assert platform["writes"][0][0]["IsvFlag"] == "uhyl"
+    assert platform["operations"] == 0
+
+
+def test_noop_does_not_save_or_query_operations(platform):
+    result = edit({"update": [{"key": "a", "title": "设置"}]})
+    assert result["status"] is True
+    assert result["data"]["changed"] is False
+    assert not platform["writes"]
+    assert not platform["operations"]
+
+
+@pytest.mark.parametrize("intent", [
+    {"clear": True}, {"replace": []}, {"clear": True, "append": []},
+    {"append": [{"key": "a", "title": "duplicate"}]},
+    {"moves": [{"key": "a", "before": "b", "after": "b"}]},
+    {"update": [{"key": "missing", "title": "X"}]},
+    {"order": ["a", "a"]},
+    {"update": [{"key": "a", "id": "replacement"}]},
+    {"update": [{"key": "a", "uploadable": True}]},
+])
+def test_invalid_edits_never_write(platform, intent):
+    result = edit(intent)
+    assert result["status"] is False
+    assert result["writeAttempted"] is False
+    assert not platform["writes"]
+
+
+def test_ambiguous_title_returns_candidates_without_write(platform):
+    platform["items"][1]["title"] = {"zh_CN": "设置"}
+    result = edit({"remove": ["设置"]})
+    assert result["errorCode"] == "DROPDOWN_MENU_TARGET_AMBIGUOUS"
+    assert len(result["data"]["candidates"]) == 2
+    assert not platform["writes"]
+
+
+def test_missing_property_is_not_empty_menu(platform, monkeypatch):
+    monkeypatch.setattr(cmd_properties, "do_get_properties",
+                        lambda *args: {"status": True, "data": {}})
+    result = edit({"append": [{"key": "c", "title": "C"}]})
+    assert result["errorCode"] == "DROPDOWN_MENU_READ_UNAVAILABLE"
+    assert not platform["writes"]
+
+
+def test_upload_aliases_are_written_and_read_back(platform):
+    result = edit({"append": [{
+        "key": "upload", "title": "上传", "uploadable": True,
+        "uploadConfig": {"accept": "pdf", "maxFiles": 3, "maxFileSize": 1024, "multiple": True},
+    }]})
+    assert result["status"] is True
+    assert platform["writes"][0][-1]["UploadConfig"] == {
+        "Suffix": "pdf", "LimitCount": 3, "LimitSize": 1024, "Multiple": True,
+    }
+    assert platform["operations"] == 0
+
+
+def test_upload_patch_retains_unmentioned_configuration(platform):
+    platform["items"][1].update(operationKey="", uploadable=True, uploadConfig={
+        "suffix": "pdf", "limitCount": 3, "limitSize": 1024, "multiple": True,
+    })
+    result = edit({"update": [{"key": "b", "uploadConfig": {"maxFiles": 5}}]})
+    assert result["status"] is True
+    assert platform["writes"][0][1]["UploadConfig"]["LimitSize"] == 1024
+    assert platform["writes"][0][1]["UploadConfig"]["LimitCount"] == 5
+
+
+def test_unknown_upload_keys_stop_before_write(platform):
+    result = edit({"append": [{"key": "c", "uploadConfig": {"typo": 3}}]})
+    assert result["status"] is False
+    assert not platform["writes"]
+
+
+@pytest.mark.parametrize("extra", [
+    {"isv": "another_vendor"},
+    {"newAuthoredProperty": "must retain"},
+    {"title": {"zh_CN": "设置", "en_US": "Settings"}},
+])
+def test_original_vendor_languages_and_unknown_properties_are_retained(platform, extra):
+    platform["items"][0].update(extra)
+    result = edit({"moves": [{"key": "a", "after": "b"}]})
+    assert result["status"] is True
+    retained = next(item for item in platform["items"] if item["key"] == "a")
+    assert all(retained[key] == value for key, value in extra.items())
+    assert platform["writes"][0][1]["Id"] == "id-a"
+
+
+def test_partial_order_keeps_unmentioned_tail(platform):
+    result = edit({"order": ["预览"]})
+    assert result["status"] is True
+    assert [item["key"] for item in platform["items"]] == ["b", "a"]
+
+
+def test_empty_operation_cannot_serve_as_business_implementation(platform, monkeypatch):
+    monkeypatch.setattr(cmd_operations, "do_list_operations", lambda *args: {
+        "status": True, "data": [{"operationKey": "empty", "operationType": "donothing",
+                                  "pluginCount": 0, "opBizRuleCount": 0}]})
+    result = edit({"append": [{"key": "new", "operation": "empty"}]})
+    assert result["errorCode"] == "DROPDOWN_MENU_OPERATION_IMPLEMENTATION_REQUIRED"
+    assert not platform["writes"]
+
+
+def test_same_value_upload_aliases_are_accepted():
+    assert cmd_properties._dropdown_upload_config({"suffix": "pdf", "accept": "pdf"}) == {"Suffix": "pdf"}
+
+
+@pytest.mark.parametrize("encoded", [False, True])
+def test_readback_extension_upload_fields_survive_title_and_option_edits(platform, monkeypatch, encoded):
+    config = {"Multiple": True, "Suffix": "pdf", "LimitCount": 5, "UnCompresspic": False,
+              "FutureOption": {"enabled": None}}
+    platform["items"][1].update(operationKey="", uploadable=True, uploadConfig={
+        "multiple": True, "suffix": "pdf", "limitCount": 5, "unCompresspic": False,
+        "futureOption": {"enabled": None},
+    })
+    load = cmd_listui.do_load_full_metadata
+    def native_load(*args, **kwargs):
+        result = load(*args, **kwargs)
+        if not platform.get("saved_document"):
+            result["data"]["formmeta"]["Items"][0]["DropdownItems"][1]["UploadConfig"] = (
+                json.dumps(config) if encoded else copy.deepcopy(config))
+        return result
+    monkeypatch.setattr(cmd_listui, "do_load_full_metadata", native_load)
+    result = edit({"update": [{"key": "b", "title": "上传模板", "uploadConfig": {"maxFiles": 6}}]})
+    assert result["status"] is True
+    actual = platform["writes"][0][1]["UploadConfig"]
+    assert isinstance(actual, str) == encoded
+    actual = json.loads(actual) if encoded else actual
+    assert actual == {**config, "LimitCount": 6}
+
+
+def test_unknown_upload_input_is_still_rejected():
+    with pytest.raises(ValueError, match="UNKNOWN"):
+        cmd_properties._normalize_dropdown_item({"key": "new", "uploadConfig": {"futureOption": True}})
+
+
+def test_item_title_can_resolve_parent_without_button_selector(platform):
+    result = cmd_properties.do_configure_dropdown_menu({}, "", "form", None, {
+        "update": [{"key": "设置", "title": "打印参数设置", "subtitle": "选择参数"}],
+    }, locale="zh_CN")
+    assert result["status"] is True
+    assert platform["writes"][0][0]["OperationKey"] == "op_a"
+    assert platform["writes"][0][0]["SubTitle"] == "选择参数"
+    assert platform["operations"] == 0
+
+
+def test_ambiguous_menu_parent_returns_candidates_without_write(platform, monkeypatch):
+    load = cmd_listui.do_load_full_metadata
+    def ambiguous(*args, **kwargs):
+        result = load(*args, **kwargs)
+        items = result["data"]["formmeta"]["Items"]
+        items.append({**copy.deepcopy(items[0]), "Key": "other_button", "Id": "other-id"})
+        return result
+    monkeypatch.setattr(cmd_listui, "do_load_full_metadata", ambiguous)
+    result = cmd_properties.do_configure_dropdown_menu({}, "", "form", None, {
+        "update": [{"key": "设置", "title": "新名称"}],
+    })
+    assert result["errorCode"] == "DROPDOWN_MENU_PARENT_REQUIRED"
+    assert len(result["data"]["candidates"]) == 2
+    assert not platform["writes"]
+
+
+@pytest.mark.parametrize("args,owner", [
+    (["queryFormsByApp", "--bad-option"], "describeCommand queryFormsByApp"),
+    (["nonexistentCommand"], "describeCommand <selected-command>"),
+])
+def test_argument_errors_keep_discovery_bounded(tmp_path, args, owner):
+    cli = Path(__file__).resolve().parents[1] / "cosmic_api.py"
+    result = subprocess.run([sys.executable, str(cli), "--stdout", *args],
+                            cwd=tmp_path, capture_output=True, text=True)
+    assert result.returncode == 2
+    receipt = json.loads(result.stdout)
+    assert receipt["recovery"]["describeCommand"] == owner
+    assert "choose from" not in receipt["message"]
+    assert len(receipt["message"]) < 500
+
+
+def test_failed_save_never_retries_or_renames(platform, monkeypatch):
+    api = mock.Mock(return_value={"status": False, "errorCode": "META_SAVE_FAIL",
+                                  "message": "key collision"})
+    monkeypatch.setattr(cmd_listui, "do_save_full_metadata", api)
+    result = edit({"update": [{"key": "a", "subtitle": "X"}]})
+    assert result["status"] is False
+    assert result["recovery"]["automaticRetry"] is False
+    api.assert_called_once()
+    assert api.call_args.args[3]["formmeta"]["Items"][0]["DropdownItems"][0]["Key"] == "a"
+    assert platform["items"] == CURRENT
+
+
+def test_readback_mismatch_is_not_success(platform, monkeypatch):
+    # API says saved, but independently read metadata still contains the old title.
+    monkeypatch.setattr(cmd_listui, "do_save_full_metadata",
+                        lambda *args, **kwargs: {"status": True, "data": {}})
+    result = edit({"update": [{"key": "a", "title": "New"}]})
+    assert result["status"] is False
+    assert result["verification"]["verified"] is False
+    assert result["data"]["changed"] is None
+
+
+def test_missing_operation_is_not_replaced_by_placeholder(platform):
+    result = edit({"append": [{"key": "c", "operation": "missing"}]})
+    assert result["errorCode"] == "DROPDOWN_MENU_OPERATION_NOT_FOUND"
+    assert not platform["writes"]
+
+
+def test_generic_replacement_requires_semantic_edit(platform):
+    result = cmd_properties.do_set_complex_property({}, "", "form", "dropdownItems", [],
+                                                    element_key="print")
+    assert result["errorCode"] == "DROPDOWN_MENU_EDIT_REQUIRED"
+    assert not platform["writes"]
+
+
+def test_identity_comparison_is_case_sensitive():
+    assert cmd_properties._dropdown_mismatches([{"Key": "a"}], [{"Key": "A"}])
+
+
+def test_property_discovery_routes_to_semantic_menu_edit():
+    result = cmd_properties._describe_one_property(
+        {"propertyName": "DropdownItems", "editable": True, "complexity": "complex"},
+        None, None)
+    assert result["inputFormat"] == "menuEditIntent"
+    assert "configureDropdownMenu" in result["guidance"]

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

@@ -2734,31 +2734,6 @@ def test_apply_form_grid_converts_fieldset_to_runtime_flex(
     assert "layoutProjection" not in result["data"]
 
 
-def test_form_control_traits_match_harvested_platform_superclasses():
-    app_build = next(
-        parent for parent in pathlib.Path(__file__).resolve().parents
-        if parent.name == "app-build"
-    )
-    scripts_root = app_build / "scripts"
-    if str(scripts_root) not in sys.path:
-        sys.path.insert(0, str(scripts_root))
-    from workspace_layout import repository_root
-    repo = repository_root(app_build)
-    source = __import__("json").loads(
-        (repo / "tests/metadata-xml-corpus/contracts/element-superclasses.json")
-        .read_text(encoding="utf-8")
-    )
-    for type_name, traits in _FORM_CONTROL_TRAITS.items():
-        chain = []
-        current = type_name
-        seen = set()
-        while current in source and current not in seen:
-            seen.add(current)
-            current = source[current]
-            chain.append(current)
-        assert chain == traits["superclasses"]
-
-
 def test_compile_form_tabs_moves_complete_subtrees_and_leaves_attachment_outside():
     intent, evidence = compile_form_tabs_intent({
         "pages": [

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

@@ -28,6 +28,48 @@ def _minimal_bill_entity(*, biz_name: str, fields: list[dict]) -> dict:
 
 
 class FieldDecoratorTrimAndAliasTest(unittest.TestCase):
+    def test_explicit_names_are_checked_after_prefixing(self):
+        raw = {"entities": [{
+            **_minimal_bill_entity(biz_name="bill", fields=[]), "logicalName": "x" * 25,
+        }]}
+        with self.assertRaisesRegex(ValueError, "including developer prefix"):
+            field_decorator.decorate_artifact(raw, "acme", "acme_app", standard=False)
+        raw["entities"][0]["logicalName"] = "mybill"
+        raw["entities"][0]["fields"] = [
+            {"bizWord": "one", "logicalName": "same", "displayName": "一", "dataType": "TextField"},
+            {"bizWord": "two", "logicalName": "acme_same", "displayName": "二", "dataType": "TextField"},
+        ]
+        with self.assertRaisesRegex(ValueError, "duplicate fieldKey"):
+            field_decorator.decorate_artifact(raw, "acme", "acme_app", standard=False)
+
+    def test_explicit_logical_identifiers_are_namespaced_once_with_references(self):
+        for prefix in ("", "acme_"):
+            raw = {"entities": [{
+                **_minimal_bill_entity(biz_name="bill", fields=[{
+                    "bizWord": "remark", "logicalName": prefix + "note",
+                    "displayName": "备注", "dataType": "TextField",
+                }]), "logicalName": prefix + "mybill",
+            }], "propertySettings": [{"elementKey": prefix + "note", "settingType": "simple",
+                                      "properties": {"Name": "备注"}}],
+               "uiLayout": {"containers": [{"key": "panel", "children": [prefix + "note"]}]},
+               "rules": [{"ruleType": "formRule", "triggerField": prefix + "note",
+                          "mountPoint": prefix + "mybill", "preCondition": prefix + "note" + " = '123'"}],
+               "operations": [{"operationKey": "save", "parameter": {
+                   "fieldKey": prefix + "note", "formNumber": prefix + "mybill",
+                   "message": prefix + "note", "entityId": "external-id"}}]}
+            decorated = field_decorator.decorate_artifact(raw, "acme", "acme_app", standard=False)
+            self.assertEqual(decorated["entities"][0]["entityKey"], "acme_mybill")
+            self.assertEqual(decorated["entities"][0]["fields"][0]["fieldKey"], "acme_note")
+            self.assertEqual(decorated["propertySettings"][0]["elementKey"], "acme_note")
+            self.assertEqual(decorated["uiLayout"]["containers"][0]["children"], ["acme_note"])
+            projection = field_decorator.make_entity_key_map(raw["entities"], "acme", standard=False)
+            self.assertEqual(projection[prefix + "mybill"], "acme_mybill")
+            self.assertEqual(decorated["rules"][0]["triggerField"], "acme_note")
+            self.assertEqual(decorated["rules"][0]["mountPoint"], "acme_mybill")
+            self.assertEqual(decorated["operations"][0]["parameter"]["fieldKey"], "acme_note")
+            self.assertEqual(decorated["operations"][0]["parameter"]["message"], prefix + "note")
+            self.assertEqual(decorated["operations"][0]["parameter"]["entityId"], "external-id")
+
     """decorate_artifact: trimming + alias mapping, ensuring rules/entryToolbar can be replaced."""
 
     def setUp(self) -> None:
@@ -88,7 +130,7 @@ class FieldDecoratorTrimAndAliasTest(unittest.TestCase):
             )
 
     def test_explicit_entity_identity_is_preserved_while_table_is_projected(self) -> None:
-        logical_name = "AcmePromotionCouponV2026"  # exact 24-character user identity
+        logical_name = "acme_PromotionCoupon2026"  # prefixed identity within the entity budget
         raw = {
             "entities": [
                 {
@@ -220,7 +262,7 @@ class FieldDecoratorTrimAndAliasTest(unittest.TestCase):
         self.assertEqual(253, action["RET"])
         self.assertEqual(1, action["Seq"])
 
-    def test_call_field_change_is_rejected_by_authoring_compiler(self) -> None:
+    def test_call_field_change_is_serialized_by_authoring_compiler(self) -> None:
         raw = {
             "entities": [_minimal_bill_entity(
                 biz_name="rule_bill",
@@ -231,10 +273,12 @@ class FieldDecoratorTrimAndAliasTest(unittest.TestCase):
                 "trueActions": [{"actionType": "CallFieldChangeAction", "expression": "target"}],
             }],
         }
-        with self.assertRaisesRegex(ValueError, "RULE_ACTION_CONTRACT_BLOCKED"):
-            field_decorator.decorate_artifact(
-                raw, isv="acme", app_number="acme_app", standard=False
-            )
+        out = field_decorator.decorate_artifact(
+            raw, isv="acme", app_number="acme_app", standard=False
+        )
+        action = out["rules"][0]["trueActions"][0]
+        self.assertEqual("CallFieldChangeAction", action["ActionType"])
+        self.assertEqual(773, action["RET"])
 
     def test_bizword_projection_updates_dynamic_layout_children(self) -> None:
         long_bw = "next_followup_date"