fix: Revert changes to backup restore-format

Author: kdmccormick

src/openedx_content/applets/backup_restore/serializers.py

@@ -6,6 +6,7 @@
 from rest_framework import serializers
 
 from ..components import api as components_api
+from ..components.models import ComponentType
 
 
 class LearningPackageSerializer(serializers.Serializer):  # pylint: disable=abstract-method
@@ -59,52 +60,55 @@ class EntityVersionSerializer(serializers.Serializer):  # pylint: disable=abstra
 class ComponentSerializer(EntitySerializer):  # pylint: disable=abstract-method
     """
     Serializer for components.
-
-    Extracts component_type and component_code from the [entity.component]
-    section if present (archives created in Verawood or later). Falls back to
-    parsing the entity key for archives created in Ulmo.
+    Contains logic to convert entity_key to component_type and component_code.
     """
 
-    component = serializers.DictField(required=False)
-
     def validate(self, attrs):
         """
-        Custom validation logic: resolve component_type and component_code.
-
-        Archives created in Verawood or later supply an [entity.component]
-        section with ``component_type`` (e.g. "xblock.v1:problem") and
-        ``component_code`` (e.g. "my_example"). Archives created in Ulmo only
-        have the entity ``key`` in the format
-        ``"{namespace}:{type_name}:{component_code}"``, so we fall back to
-        parsing that for backwards compatibility.
+        Custom validation logic:
+        parse the entity_key into (component_type, component_code).
         """
-        component_section = attrs.pop("component", None)
-        if component_section:
-            # Verawood+ format: component_type and component_code are explicit.
-            component_type_str = component_section.get("component_type", "")
-            component_code = component_section.get("component_code", "")
-            try:
-                namespace, type_name = component_type_str.split(":", 1)
-            except ValueError as exc:
-                raise serializers.ValidationError(
-                    {"component": f"Invalid component_type format: {component_type_str!r}. "
-                                  "Expected '{namespace}:{type_name}'."}
-                ) from exc
-            component_type_obj = components_api.get_or_create_component_type(namespace, type_name)
-        else:
-            # Ulmo (legacy) format: parse the entity key.
-            entity_key = attrs["key"]
-            try:
-                component_type_obj, component_code = (
-                    components_api.get_or_create_component_type_by_entity_key(entity_key)
-                )
-            except ValueError as exc:
-                raise serializers.ValidationError({"key": str(exc)})
-        attrs["component_type"] = component_type_obj
-        attrs["component_code"] = component_code
+        entity_key = attrs["key"]
+        try:
+            component_type_obj, component_code = _get_or_create_component_type_by_entity_key(entity_key)
+            attrs["component_type"] = component_type_obj
+            attrs["component_code"] = component_code
+        except ValueError as exc:
+            raise serializers.ValidationError({"key": str(exc)})
         return attrs
 
 
+def _get_or_create_component_type_by_entity_key(entity_key: str) -> tuple[ComponentType, str]:
+    """
+    Get or create a ComponentType based on a full [entity].key string.
+
+    The entity key is expected to be in the format
+    ``"{namespace}:{type_name}:{component_code}"``. This function will parse out
+    the ``namespace`` and ``type_name`` parts and use those to get or create the
+    ComponentType.
+
+    Raises ValueError if the entity_key is not in the expected format.
+
+    Historical note: In Ulmo, this function was part of the public API. This was
+    inappropriate because the exact format of entity_keys is just a convention
+    rather than something API callers should count on. That said, it is safe to
+    assume that in all "v1" archives, the components' entity keys are safe to
+    parse into (namespace, type, code). So, we have moved this parsing logic
+    from the public API to just this internal halper function.  Future devs,
+    please to not make new external guarantees about the format of entity keys
+    (aka entity_refs).  A future "v2" backup-restore format will drop this
+    assumption of parse-ability..
+    """
+    try:
+        namespace, type_name, component_code = entity_key.split(':', 2)
+    except ValueError as exc:
+        raise ValueError(
+            f"Invalid entity_key format: {entity_key!r}. "
+            "Expected format: '{namespace}:{type_name}:{component_code}'"
+        ) from exc
+    return components_api.get_or_create_component_type(namespace, type_name), component_code
+
+
 class ComponentVersionSerializer(EntityVersionSerializer):  # pylint: disable=abstract-method
     """
     Serializer for component versions.

src/openedx_content/applets/backup_restore/toml.py

@@ -108,15 +108,6 @@ def _get_toml_publishable_entity_table(
         published_table.add(tomlkit.comment("unpublished: no published_version_num"))
     entity_table.add("published", published_table)
 
-    if hasattr(entity, "component"):
-        component = entity.component
-        component_table = tomlkit.table()
-        # Write component_type and component_code explicitly so that restore
-        # (Verawood and later) does not need to parse the entity key.
-        component_table.add("component_type", str(component.component_type))
-        component_table.add("component_code", component.component_code)
-        entity_table.add("component", component_table)
-
     if hasattr(entity, "container"):
         container_table = tomlkit.table()
         container_types = ["section", "subsection", "unit"]

tests/openedx_content/applets/backup_restore/test_restore.py

@@ -8,7 +8,6 @@
 from django.core.management import call_command
 from django.test import TestCase
 
-from openedx_content.applets.backup_restore.serializers import ComponentSerializer
 from openedx_content.applets.backup_restore.zipper import LearningPackageUnzipper, generate_staged_lp_key
 from openedx_content.applets.collections import api as collections_api
 from openedx_content.applets.components import api as components_api
@@ -361,80 +360,6 @@ def test_success_metadata_using_user_context(self):
         assert metadata == expected_metadata
 
 
-class ComponentSerializerBackcompatTest(TestCase):
-    """
-    Unit tests for ComponentSerializer's back-compat handling of Ulmo archives
-    (entity key only) vs. Verawood+ archives ([entity.component] section).
-    """
-
-    BASE_DATA = {
-        "can_stand_alone": True,
-        "key": "xblock.v1:problem:my_code",
-        "created": "2025-09-04T22:51:59Z",
-    }
-
-    def _serialize(self, extra=None, base=None):
-        data = {**(base or self.BASE_DATA), **(extra or {})}
-        s = ComponentSerializer(data=data)
-        s.is_valid()
-        return s
-
-    def test_legacy_entity_key_parsed(self):
-        """Ulmo archives have no [entity.component] section; fall back to parsing the entity key."""
-        s = self._serialize()
-        assert s.is_valid(), s.errors
-        assert s.validated_data["component_type"].namespace == "xblock.v1"
-        assert s.validated_data["component_type"].name == "problem"
-        assert s.validated_data["component_code"] == "my_code"
-        assert "component" not in s.validated_data
-
-    def test_new_component_section(self):
-        """Verawood+ archives supply an explicit [entity.component] section."""
-        s = self._serialize({
-            "component": {
-                "component_type": "xblock.v1:problem",
-                "component_code": "my_code",
-            }
-        })
-        assert s.is_valid(), s.errors
-        assert s.validated_data["component_type"].namespace == "xblock.v1"
-        assert s.validated_data["component_type"].name == "problem"
-        assert s.validated_data["component_code"] == "my_code"
-        assert "component" not in s.validated_data
-
-    def test_component_section_overrides_key(self):
-        """When [entity.component] is present, it is used even if the key has different info."""
-        s = self._serialize({
-            "component": {
-                "component_type": "xblock.v1:html",
-                "component_code": "different_code",
-            }
-        })
-        assert s.is_valid(), s.errors
-        assert s.validated_data["component_type"].name == "html"
-        assert s.validated_data["component_code"] == "different_code"
-
-    def test_invalid_entity_key_format(self):
-        """Entity key without enough colons raises a validation error."""
-        s = self._serialize(base={
-            "can_stand_alone": True,
-            "key": "invalid-key",
-            "created": "2025-09-04T22:51:59Z",
-        })
-        assert not s.is_valid()
-
-    def test_invalid_component_type_format(self):
-        """component_type without a colon raises a validation error."""
-        s = self._serialize({
-            "component": {
-                "component_type": "no-colon-here",
-                "component_code": "my_code",
-            }
-        })
-        assert not s.is_valid()
-        assert "component" in s.errors
-
-
 class RestoreUtilitiesTest(TestCase):
     """Tests for utility functions used in the restore process."""