xcore-protocol 0.6.2__tar.gz → 0.7.0__tar.gz

{xcore_protocol-0.6.2 → xcore_protocol-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xcore-protocol
-Version: 0.6.2
+Version: 0.7.0
 Summary: Canonical cross-service protocol for the XCore ecosystem
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{xcore_protocol-0.6.2 → xcore_protocol-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xcore-protocol"
-version = "0.6.2"
+version = "0.7.0"
 description = "Canonical cross-service protocol for the XCore ecosystem"
 readme = "README.md"
 requires-python = ">=3.11"

{xcore_protocol-0.6.2 → xcore_protocol-0.7.0}/python/tests/test_canonical_protocol_fixtures.py

@@ -107,8 +107,8 @@ CANONICAL_CASES: list[tuple[str, Path, Path, type[Any], CanonicalAssertion]] = [
     ),
     (
         "server_heartbeat",
-        spec_root() / "messages" / "chat" / "server.heartbeat.v1.json",
-        CANONICAL_FIXTURES_ROOT / "chat" / "server.heartbeat.v1.json",
+        spec_root() / "messages" / "server" / "server.heartbeat.v1.json",
+        CANONICAL_FIXTURES_ROOT / "server" / "server.heartbeat.v1.json",
         ServerHeartbeatV1,
         _assert_heartbeat_semantics,
     ),

xcore_protocol-0.7.0/python/tests/test_chat_fixtures.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import assert_invalid, assert_valid
+
+
+VALID_CASES = [
+    (
+        spec_root() / "messages" / "chat" / "chat.message.v1.json",
+        fixtures_root() / "valid" / "chat" / "chat.message.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "chat" / "chat.global.v1.json",
+        fixtures_root() / "valid" / "chat" / "chat.global.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "chat" / "chat.discord-ingress.command.v1.json",
+        fixtures_root() / "valid" / "chat" / "chat.discord-ingress.command.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "chat" / "chat.private.v1.json",
+        fixtures_root() / "valid" / "chat" / "chat.private.v1.json",
+    ),
+]
+
+
+INVALID_CASES = [
+    (
+        spec_root() / "messages" / "chat" / "chat.message.v1.json",
+        fixtures_root() / "invalid" / "chat" / "chat.message.v1.snake-author.json",
+    ),
+    (
+        spec_root() / "messages" / "chat" / "chat.private.v1.json",
+        fixtures_root() / "invalid" / "chat" / "chat.private.v1.snake-from.json",
+    ),
+]
+
+
+def test_valid_chat_fixtures_pass() -> None:
+    for schema_path, fixture_path in VALID_CASES:
+        assert_valid(schema_path, fixture_path)
+
+
+def test_invalid_chat_fixtures_fail() -> None:
+    for schema_path, fixture_path in INVALID_CASES:
+        error = assert_invalid(schema_path, fixture_path)
+        assert error is not None
+
+
+def test_chat_fixture_inventory_exists() -> None:
+    chat_valid_dir = fixtures_root() / "valid" / "chat"
+    chat_invalid_dir = fixtures_root() / "invalid" / "chat"
+
+    assert chat_valid_dir.exists()
+    assert chat_invalid_dir.exists()
+    assert any(chat_valid_dir.iterdir())
+    assert any(chat_invalid_dir.iterdir())

xcore_protocol-0.7.0/python/tests/test_generated_chat_models.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from xcore_protocol.generated import (
+    CHAT_DISCORD_INGRESS_COMMAND_V1,
+    CHAT_GLOBAL_V1,
+    CHAT_MESSAGE_V1,
+    CHAT_PRIVATE_V1,
+    ChatDiscordIngressCommandV1,
+    ChatGlobalV1,
+    ChatMessageV1,
+    ChatPrivateV1,
+    ROUTES_BY_MESSAGE,
+)
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import load_json, validate_instance
+
+
+def test_generated_chat_message_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "chat" / "chat.message.v1.json")
+
+    model = ChatMessageV1.from_payload(payload)
+
+    assert model == ChatMessageV1(authorName="PlayerOne", message="Hello there", server="mini-pvp")
+    assert model.to_payload() == payload
+    validate_instance(spec_root() / "messages" / "chat" / "chat.message.v1.json", model.to_payload())
+
+
+def test_generated_chat_global_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "chat" / "chat.global.v1.json")
+
+    model = ChatGlobalV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(spec_root() / "messages" / "chat" / "chat.global.v1.json", model.to_payload())
+
+
+def test_generated_chat_discord_ingress_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "chat" / "chat.discord-ingress.command.v1.json")
+
+    model = ChatDiscordIngressCommandV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "chat" / "chat.discord-ingress.command.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_chat_private_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "chat" / "chat.private.v1.json")
+
+    model = ChatPrivateV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "chat" / "chat.private.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_chat_models_remain_strict() -> None:
+    invalid_payload = load_json(fixtures_root() / "invalid" / "chat" / "chat.message.v1.snake-author.json")
+
+    try:
+        ChatMessageV1.from_payload(invalid_payload)
+    except ValueError as error:
+        assert "missing required fields" in str(error) or "unexpected fields" in str(error)
+    else:
+        raise AssertionError("Expected strict generated model parsing to reject non-canonical keys")
+
+    invalid_private_payload = load_json(fixtures_root() / "invalid" / "chat" / "chat.private.v1.snake-from.json")
+
+    try:
+        ChatPrivateV1.from_payload(invalid_private_payload)
+    except ValueError as error:
+        assert "missing required fields" in str(error) or "unexpected fields" in str(error)
+    else:
+        raise AssertionError("Expected strict generated private-message parsing to reject non-canonical keys")
+
+
+def test_generated_route_registry_includes_chat_messages() -> None:
+    assert CHAT_MESSAGE_V1.payloadType is ChatMessageV1
+    assert CHAT_GLOBAL_V1.payloadType is ChatGlobalV1
+    assert CHAT_DISCORD_INGRESS_COMMAND_V1.payloadType is ChatDiscordIngressCommandV1
+    assert CHAT_PRIVATE_V1.payloadType is ChatPrivateV1
+    assert ROUTES_BY_MESSAGE[("chat.message", 1)].stream == "xcore:evt:chat:message"
+    assert ROUTES_BY_MESSAGE[("chat.global", 1)].stream == "xcore:evt:chat:global"
+    assert ROUTES_BY_MESSAGE[("chat.private", 1)].stream == "xcore:evt:chat:private"
+    assert ROUTES_BY_MESSAGE[("chat.discord-ingress.command", 1)].bindings == {"server": "payload.server"}

xcore_protocol-0.7.0/python/tests/test_generated_identity_models.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from xcore_protocol.generated import (
+    PLAYER_ACTIVE_BADGE_CHANGED_COMMAND_V1,
+    PLAYER_BADGE_INVENTORY_CHANGED_COMMAND_V1,
+    PLAYER_BADGE_SYMBOL_COLOR_MODE_CHANGED_COMMAND_V1,
+    PLAYER_CUSTOM_NICKNAME_CHANGED_COMMAND_V1,
+    PLAYER_JOIN_LEAVE_V1,
+    PlayerActiveBadgeChangedCommandV1,
+    PlayerBadgeInventoryChangedCommandV1,
+    PlayerBadgeSymbolColorModeChangedCommandV1,
+    PlayerCustomNicknameChangedCommandV1,
+    PlayerJoinLeaveV1,
+    ROUTES_BY_MESSAGE,
+)
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import load_json, validate_instance
+
+
+def test_generated_player_join_leave_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "identity" / "player.join-leave.v1.json")
+
+    model = PlayerJoinLeaveV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(spec_root() / "messages" / "identity" / "player.join-leave.v1.json", model.to_payload())
+
+
+def test_generated_player_custom_nickname_changed_command_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "identity" / "player.custom-nickname.changed.command.v1.json")
+
+    model = PlayerCustomNicknameChangedCommandV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "identity" / "player.custom-nickname.changed.command.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_player_active_badge_changed_command_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "identity" / "player.active-badge.changed.command.v1.json")
+
+    model = PlayerActiveBadgeChangedCommandV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "identity" / "player.active-badge.changed.command.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_player_badge_inventory_changed_command_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "identity" / "player.badge-inventory.changed.command.v1.json")
+
+    model = PlayerBadgeInventoryChangedCommandV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "identity" / "player.badge-inventory.changed.command.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_player_badge_symbol_color_mode_changed_command_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "identity" / "player.badge-symbol-color-mode.changed.command.v1.json")
+
+    model = PlayerBadgeSymbolColorModeChangedCommandV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "identity" / "player.badge-symbol-color-mode.changed.command.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_identity_models_remain_strict() -> None:
+    invalid_player_payload = load_json(
+        fixtures_root() / "invalid" / "identity" / "player.custom-nickname.changed.command.v1.legacy-uuid.json"
+    )
+
+    try:
+        PlayerCustomNicknameChangedCommandV1.from_payload(invalid_player_payload)
+    except ValueError as error:
+        assert "missing required fields" in str(error) or "unexpected fields" in str(error)
+    else:
+        raise AssertionError("Expected strict generated player-session command parsing to reject legacy uuid field")
+
+
+def test_generated_route_registry_includes_identity_messages() -> None:
+    assert PLAYER_JOIN_LEAVE_V1.payloadType is PlayerJoinLeaveV1
+    assert PLAYER_CUSTOM_NICKNAME_CHANGED_COMMAND_V1.payloadType is PlayerCustomNicknameChangedCommandV1
+    assert PLAYER_ACTIVE_BADGE_CHANGED_COMMAND_V1.payloadType is PlayerActiveBadgeChangedCommandV1
+    assert PLAYER_BADGE_INVENTORY_CHANGED_COMMAND_V1.payloadType is PlayerBadgeInventoryChangedCommandV1
+    assert PLAYER_BADGE_SYMBOL_COLOR_MODE_CHANGED_COMMAND_V1.payloadType is PlayerBadgeSymbolColorModeChangedCommandV1
+    assert ROUTES_BY_MESSAGE[("player.join-leave", 1)].stream == "xcore:evt:player:joinleave"
+    assert ROUTES_BY_MESSAGE[("player.custom-nickname.changed.command", 1)].stream == "xcore:cmd:player-custom-nickname:{server}"
+    assert ROUTES_BY_MESSAGE[("player.active-badge.changed.command", 1)].stream == "xcore:cmd:player-active-badge:{server}"
+    assert ROUTES_BY_MESSAGE[("player.badge-inventory.changed.command", 1)].stream == "xcore:cmd:player-badge-inventory:{server}"
+    assert ROUTES_BY_MESSAGE[("player.badge-symbol-color-mode.changed.command", 1)].stream == "xcore:cmd:player-badge-symbol-color-mode:{server}"

xcore_protocol-0.7.0/python/tests/test_generated_security_models.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from xcore_protocol.generated import (
+    PLAYER_PASSWORD_RESET_COMMAND_V1,
+    PlayerPasswordResetCommandV1,
+    ROUTES_BY_MESSAGE,
+)
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import load_json, validate_instance
+
+
+def test_generated_player_password_reset_command_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "security" / "player.password-reset.command.v1.json")
+
+    model = PlayerPasswordResetCommandV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(
+        spec_root() / "messages" / "security" / "player.password-reset.command.v1.json",
+        model.to_payload(),
+    )
+
+
+def test_generated_security_models_remain_strict() -> None:
+    invalid_password_reset_payload = load_json(
+        fixtures_root() / "invalid" / "security" / "player.password-reset.command.v1.legacy-uuid.json"
+    )
+
+    try:
+        PlayerPasswordResetCommandV1.from_payload(invalid_password_reset_payload)
+    except ValueError as error:
+        assert "missing required fields" in str(error) or "unexpected fields" in str(error)
+    else:
+        raise AssertionError("Expected strict generated password-reset parsing to reject legacy uuid field")
+
+
+def test_generated_route_registry_includes_security_messages() -> None:
+    assert PLAYER_PASSWORD_RESET_COMMAND_V1.payloadType is PlayerPasswordResetCommandV1
+    assert ROUTES_BY_MESSAGE[("player.password-reset.command", 1)].stream == "xcore:cmd:player-password-reset:{server}"

xcore_protocol-0.7.0/python/tests/test_generated_server_models.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from xcore_protocol.generated import (
+    PLAYER_DATA_CACHE_RELOAD_COMMAND_V1,
+    SERVER_ACTION_V1,
+    SERVER_COMMAND_EXECUTE_COMMAND_V1,
+    SERVER_HEARTBEAT_V1,
+    PlayerDataCacheReloadCommandV1,
+    ServerActionV1,
+    ServerCommandExecuteCommandV1,
+    ServerHeartbeatV1,
+    ROUTES_BY_MESSAGE,
+)
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import load_json, validate_instance
+
+
+def test_generated_server_action_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "server" / "server.action.v1.json")
+
+    model = ServerActionV1.from_payload(payload)
+
+    assert model.to_payload() == payload
+    validate_instance(spec_root() / "messages" / "server" / "server.action.v1.json", model.to_payload())
+
+
+def test_generated_server_heartbeat_roundtrip_matches_fixture() -> None:
+    payload = load_json(fixtures_root() / "valid" / "server" / "server.heartbeat.v1.json")
+
+    model = ServerHeartbeatV1.from_payload(payload)
+
+    assert model == ServerHeartbeatV1(
+        serverName="mini-pvp",
+        discordChannelId=1234567890123456789,
+        players=4,
+        maxPlayers=12,
+        version="146.1",
+        host="play.example.com",
+        port=6567,
+    )
+    assert model.to_payload() == payload
+    validate_instance(spec_root() / "messages" / "server" / "server.heartbeat.v1.json", model.to_payload())
+
+
+def test_generated_server_heartbeat_rejects_alias_fields() -> None:
+    invalid_payload = load_json(
+        fixtures_root() / "invalid" / "server" / "server.heartbeat.v1.server-host-alias.json"
+    )
+
+    try:
+        ServerHeartbeatV1.from_payload(invalid_payload)
+    except ValueError as error:
+        assert "unexpected fields" in str(error)
+    else:
+        raise AssertionError("Expected strict generated heartbeat parsing to reject alias fields")
+
+
+def test_generated_route_registry_includes_server_messages() -> None:
+    assert SERVER_ACTION_V1.payloadType is ServerActionV1
+    assert SERVER_HEARTBEAT_V1.payloadType is ServerHeartbeatV1
+    assert SERVER_COMMAND_EXECUTE_COMMAND_V1.payloadType is ServerCommandExecuteCommandV1
+    assert PLAYER_DATA_CACHE_RELOAD_COMMAND_V1.payloadType is PlayerDataCacheReloadCommandV1
+    assert ROUTES_BY_MESSAGE[("server.action", 1)].stream == "xcore:evt:server:action"
+    assert ROUTES_BY_MESSAGE[("server.heartbeat", 1)].stream == "xcore:evt:server:heartbeat"
+    assert ROUTES_BY_MESSAGE[("server-command.execute.command", 1)].stream == "xcore:cmd:execute-command:broadcast"
+    assert ROUTES_BY_MESSAGE[("player-data-cache.reload.command", 1)].stream == "xcore:cmd:reload-cache:{server}"

xcore_protocol-0.7.0/python/tests/test_identity_fixtures.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import assert_invalid, assert_valid
+
+
+VALID_CASES = [
+    (
+        spec_root() / "messages" / "identity" / "player.join-leave.v1.json",
+        fixtures_root() / "valid" / "identity" / "player.join-leave.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.custom-nickname.changed.command.v1.json",
+        fixtures_root() / "valid" / "identity" / "player.custom-nickname.changed.command.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.active-badge.changed.command.v1.json",
+        fixtures_root() / "valid" / "identity" / "player.active-badge.changed.command.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.badge-inventory.changed.command.v1.json",
+        fixtures_root() / "valid" / "identity" / "player.badge-inventory.changed.command.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.badge-symbol-color-mode.changed.command.v1.json",
+        fixtures_root() / "valid" / "identity" / "player.badge-symbol-color-mode.changed.command.v1.json",
+    ),
+]
+
+
+INVALID_CASES = [
+    (
+        spec_root() / "messages" / "identity" / "player.join-leave.v1.json",
+        fixtures_root() / "invalid" / "identity" / "player.join-leave.v1.legacy-join.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.custom-nickname.changed.command.v1.json",
+        fixtures_root() / "invalid" / "identity" / "player.custom-nickname.changed.command.v1.legacy-uuid.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.active-badge.changed.command.v1.json",
+        fixtures_root() / "invalid" / "identity" / "player.active-badge.changed.command.v1.legacy-uuid.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.badge-inventory.changed.command.v1.json",
+        fixtures_root() / "invalid" / "identity" / "player.badge-inventory.changed.command.v1.legacy-uuid.json",
+    ),
+    (
+        spec_root() / "messages" / "identity" / "player.badge-symbol-color-mode.changed.command.v1.json",
+        fixtures_root() / "invalid" / "identity" / "player.badge-symbol-color-mode.changed.command.v1.legacy-uuid.json",
+    ),
+]
+
+
+def test_valid_identity_fixtures_pass() -> None:
+    for schema_path, fixture_path in VALID_CASES:
+        assert_valid(schema_path, fixture_path)
+
+
+def test_invalid_identity_fixtures_fail() -> None:
+    for schema_path, fixture_path in INVALID_CASES:
+        error = assert_invalid(schema_path, fixture_path)
+        assert error is not None
+
+
+def test_identity_fixture_inventory_exists() -> None:
+    valid_dir = fixtures_root() / "valid" / "identity"
+    invalid_dir = fixtures_root() / "invalid" / "identity"
+
+    assert valid_dir.exists()
+    assert invalid_dir.exists()
+    assert any(valid_dir.iterdir())
+    assert any(invalid_dir.iterdir())

{xcore_protocol-0.6.2 → xcore_protocol-0.7.0}/python/tests/test_normalized_route_model.py

@@ -92,80 +92,33 @@ def test_generation_plan_only_uses_reachable_maps_shared_types() -> None:
 def test_generation_plan_supports_chat_family_without_shared_refs() -> None:
     plan = load_generation_plan(family="chat")
 
-    assert [schema.title for schema in plan.shared_schemas] == [
-        "MapEntryV1",
-        "MapFileSourceV1",
-    ]
+    assert [schema.title for schema in plan.shared_schemas] == []
     assert [schema.title for schema in plan.message_schemas_for("chat")] == [
         "ChatDiscordIngressCommandV1",
         "ChatGlobalV1",
         "ChatMessageV1",
         "ChatPrivateV1",
-        "PlayerDataCacheReloadCommandV1",
-        "PlayerActiveBadgeChangedCommandV1",
-        "PlayerBadgeInventoryChangedCommandV1",
-        "PlayerBadgeSymbolColorModeChangedCommandV1",
-        "PlayerCustomNicknameChangedCommandV1",
-        "PlayerJoinLeaveV1",
-        "PlayerPasswordResetCommandV1",
-        "ServerCommandExecuteCommandV1",
-        "ServerActionV1",
-        "ServerHeartbeatV1",
     ]
     assert [route.message_type for route in plan.routes_for("chat")] == [
         "chat.message",
         "chat.global",
         "chat.discord-ingress.command",
         "chat.private",
-        "server.action",
-        "player.join-leave",
-        "player.custom-nickname.changed.command",
-        "player.active-badge.changed.command",
-        "player.badge-inventory.changed.command",
-        "player.badge-symbol-color-mode.changed.command",
-        "player.password-reset.command",
-        "player-data-cache.reload.command",
-        "server-command.execute.command",
-        "server.heartbeat",
-    ]
-    assert [schema.title for schema in plan.map_schemas] == [
-        "MapsListRequestV1",
-        "MapsListResponseV1",
-        "MapsLoadCommandV1",
-        "MapsRemoveRequestV1",
-        "MapsRemoveResponseV1",
     ]
     assert [route.constant_name for route in plan.chat_routes] == [
         "CHAT_MESSAGE_V1",
         "CHAT_GLOBAL_V1",
         "CHAT_DISCORD_INGRESS_COMMAND_V1",
         "CHAT_PRIVATE_V1",
-        "SERVER_ACTION_V1",
-        "PLAYER_JOIN_LEAVE_V1",
-        "PLAYER_CUSTOM_NICKNAME_CHANGED_COMMAND_V1",
-        "PLAYER_ACTIVE_BADGE_CHANGED_COMMAND_V1",
-        "PLAYER_BADGE_INVENTORY_CHANGED_COMMAND_V1",
-        "PLAYER_BADGE_SYMBOL_COLOR_MODE_CHANGED_COMMAND_V1",
-        "PLAYER_PASSWORD_RESET_COMMAND_V1",
-        "PLAYER_DATA_CACHE_RELOAD_COMMAND_V1",
-        "SERVER_COMMAND_EXECUTE_COMMAND_V1",
-        "SERVER_HEARTBEAT_V1",
-    ]
-    assert [route.constant_name for route in plan.map_routes] == [
-        "MAPS_LIST_REQUEST_V1",
-        "MAPS_REMOVE_REQUEST_V1",
-        "MAPS_LOAD_COMMAND_V1",
     ]
 
 
 def test_generation_plan_keeps_family_inputs_separate() -> None:
     plan = load_generation_plan(family="chat")
 
-    assert [family_input.family for family_input in plan.family_inputs] == ["maps", "chat"]
-    assert plan.family_inputs[0].message_schemas == plan.message_schemas_for("maps")
-    assert plan.family_inputs[0].routes == plan.routes_for("maps")
-    assert plan.family_inputs[1].message_schemas == plan.message_schemas_for("chat")
-    assert plan.family_inputs[1].routes == plan.routes_for("chat")
+    assert [family_input.family for family_input in plan.family_inputs] == ["chat"]
+    assert plan.family_inputs[0].message_schemas == plan.message_schemas_for("chat")
+    assert plan.family_inputs[0].routes == plan.routes_for("chat")
 
 
 def test_generation_plan_supports_discord_family_with_nested_shared_refs() -> None:

xcore_protocol-0.7.0/python/tests/test_security_fixtures.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import assert_invalid, assert_valid
+
+
+VALID_CASES = [
+    (
+        spec_root() / "messages" / "security" / "player.password-reset.command.v1.json",
+        fixtures_root() / "valid" / "security" / "player.password-reset.command.v1.json",
+    ),
+]
+
+
+INVALID_CASES = [
+    (
+        spec_root() / "messages" / "security" / "player.password-reset.command.v1.json",
+        fixtures_root()
+        / "invalid"
+        / "security"
+        / "player.password-reset.command.v1.legacy-uuid.json",
+    ),
+]
+
+
+def test_valid_security_fixtures_pass() -> None:
+    for schema_path, fixture_path in VALID_CASES:
+        assert_valid(schema_path, fixture_path)
+
+
+def test_invalid_security_fixtures_fail() -> None:
+    for schema_path, fixture_path in INVALID_CASES:
+        error = assert_invalid(schema_path, fixture_path)
+        assert error is not None
+
+
+def test_security_fixture_inventory_exists() -> None:
+    valid_dir = fixtures_root() / "valid" / "security"
+    invalid_dir = fixtures_root() / "invalid" / "security"
+
+    assert valid_dir.exists()
+    assert invalid_dir.exists()
+    assert any(valid_dir.iterdir())
+    assert any(invalid_dir.iterdir())

xcore_protocol-0.7.0/python/tests/test_server_fixtures.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from xcore_protocol.paths import fixtures_root, spec_root
+from xcore_protocol.schema_validation import assert_invalid, assert_valid
+
+
+VALID_CASES = [
+    (
+        spec_root() / "messages" / "server" / "server.action.v1.json",
+        fixtures_root() / "valid" / "server" / "server.action.v1.json",
+    ),
+    (
+        spec_root() / "messages" / "server" / "server.heartbeat.v1.json",
+        fixtures_root() / "valid" / "server" / "server.heartbeat.v1.json",
+    ),
+]
+
+
+INVALID_CASES = [
+    (
+        spec_root() / "messages" / "server" / "server.heartbeat.v1.json",
+        fixtures_root()
+        / "invalid"
+        / "server"
+        / "server.heartbeat.v1.server-host-alias.json",
+    ),
+    (
+        spec_root() / "messages" / "server" / "server.heartbeat.v1.json",
+        fixtures_root()
+        / "invalid"
+        / "server"
+        / "server.heartbeat.v1.missing-channel.json",
+    ),
+]
+
+
+def test_valid_server_fixtures_pass() -> None:
+    for schema_path, fixture_path in VALID_CASES:
+        assert_valid(schema_path, fixture_path)
+
+
+def test_invalid_server_fixtures_fail() -> None:
+    for schema_path, fixture_path in INVALID_CASES:
+        error = assert_invalid(schema_path, fixture_path)
+        assert error is not None
+
+
+def test_server_fixture_inventory_exists() -> None:
+    valid_dir = fixtures_root() / "valid" / "server"
+    invalid_dir = fixtures_root() / "invalid" / "server"
+
+    assert valid_dir.exists()
+    assert invalid_dir.exists()
+    assert any(valid_dir.iterdir())
+    assert any(invalid_dir.iterdir())