Align collation-divergent public event IDs with the manifest (#181)

Align collation-divergent public event IDs with the manifest

Author: alexeygrigorev

events/migrations/0008_align_public_event_ids_to_manifest.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from django.db import migrations
+
+MANIFEST_PATH = Path(__file__).resolve().parents[1] / "event_identity_manifest.json"
+
+
+def align_public_ids_to_manifest(apps, schema_editor) -> None:
+    del schema_editor
+    event_model = apps.get_model("events", "Event")
+    payload = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+    manifest_ids = {item["id"]: item["public_id"] for item in payload["events"]}
+    # The bootstrap backfill in 0006 orders by (source_key, id), which follows the database
+    # collation: PostgreSQL sorted four hyphenated tie groups differently from the reviewed
+    # manifest's byte-order numbering.  Re-align the divergent rows to the manifest so every
+    # environment serves the same canonical numeric paths.
+    divergent = [
+        event
+        for event in event_model.objects.exclude(public_id=None).order_by("id")
+        if str(event.id) in manifest_ids and event.public_id != manifest_ids[str(event.id)]
+    ]
+    if not divergent:
+        return
+    # public_id is UNIQUE, so park every divergent row on a temporary offset above the real
+    # range before writing the target values; the offset keeps each parked value distinct.
+    # Queryset updates keep the immutable-runtime-ID save guard out of the historical path.
+    offset = max(manifest_ids.values()) + len(manifest_ids)
+    for event in divergent:
+        event_model.objects.filter(pk=event.pk).update(public_id=event.public_id + offset)
+    for event in divergent:
+        event_model.objects.filter(pk=event.pk).update(public_id=manifest_ids[str(event.id)])
+
+
+class Migration(migrations.Migration):
+    dependencies = [("events", "0007_reconcile_public_event_identity")]
+
+    operations = [
+        migrations.RunPython(align_public_ids_to_manifest, migrations.RunPython.noop),
+    ]

events/tests/test_identity.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+import importlib.util
 import json
 import re
 import uuid
 from copy import deepcopy
 from pathlib import Path
-from typing import ClassVar
+from typing import Any, ClassVar
 from unittest import mock
 
 from django.core.exceptions import ImproperlyConfigured
@@ -30,6 +31,25 @@
 )
 from events.models import Event, EventAlias, EventPublicIdSequence
 
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def load_migration_function(relative_path: str, function_name: str) -> Any:
+    module_spec = importlib.util.spec_from_file_location(
+        f"loaded_{Path(relative_path).stem}", ROOT / relative_path
+    )
+    assert module_spec is not None and module_spec.loader is not None
+    module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(module)
+    return getattr(module, function_name)
+
+
+class _HistoricalAppsStub:
+    def get_model(self, app_label: str, model_name: str) -> Any:
+        if (app_label, model_name) != ("events", "Event"):
+            raise AssertionError("unexpected historical model requested")
+        return Event
+
 
 class EventIdentityManifestTests(TestCase):
     def test_checked_manifest_and_database_freeze_all_numeric_mappings_and_aliases(self) -> None:
@@ -111,6 +131,41 @@ def test_unavailable_database_serves_the_manifest_identity_snapshot(self) -> Non
             expected_paths,
         )
 
+    def test_collation_divergent_public_ids_realign_to_the_manifest(self) -> None:
+        align = load_migration_function(
+            "events/migrations/0008_align_public_event_ids_to_manifest.py",
+            "align_public_ids_to_manifest",
+        )
+        manifest = load_identity_manifest()
+        expected = {str(item.id): item.public_id for item in manifest.events}
+
+        first, second = manifest.events[11], manifest.events[12]
+        Event.objects.filter(id=first.id).update(public_id=100_000)
+        Event.objects.filter(id=second.id).update(public_id=first.public_id)
+        Event.objects.filter(id=first.id).update(public_id=second.public_id)
+        with self.assertRaisesMessage(
+            ImproperlyConfigured,
+            "Public Event UUID/public-ID mapping is incomplete",
+        ):
+            public_projection()
+
+        align(_HistoricalAppsStub(), None)
+
+        self.assertEqual(
+            dict(Event.objects.values_list("id", "public_id")),
+            {uuid.UUID(key): value for key, value in expected.items()},
+        )
+        projection = public_projection()
+        self.assertEqual(
+            {event["public_path"] for event in projection["events"]},
+            {item.canonical_path for item in manifest.events},
+        )
+        align(_HistoricalAppsStub(), None)
+        self.assertEqual(
+            dict(Event.objects.values_list("id", "public_id")),
+            {uuid.UUID(key): value for key, value in expected.items()},
+        )
+
     def test_manifest_import_replay_is_byte_stable_and_a_preflight_noop(self) -> None:
         before = tuple(Event.objects.order_by("id").values_list("id", "public_id", "slug"))
         first = import_identity_manifest(dry_run=True)

test_support/tests/test_migrations.py

@@ -71,6 +71,7 @@ def test_every_data_migration_uses_historical_apps_without_runtime_side_effects(
                 "events/migrations/0005_seed_event_identity_manifest.py",
                 "events/migrations/0006_event_public_id.py",
                 "events/migrations/0007_reconcile_public_event_identity.py",
+                "events/migrations/0008_align_public_event_ids_to_manifest.py",
             },
         )
         for path in paths: