feat: Create versioning for segments

api/conftest.py

@@ -326,8 +326,13 @@ def project(organisation):
 
 
 @pytest.fixture()
-def segment(project):
-    return Segment.objects.create(name="segment", project=project)
+def segment(project: Project):
+    _segment = Segment.objects.create(name="segment", project=project)
+    # Deep clone the segment to ensure that any bugs around
+    # versioning get bubbled up through the test suite.
+    _segment.deep_clone()
+
+    return _segment
 
 
 @pytest.fixture()

api/segments/managers.py

@@ -0,0 +1,11 @@
+from core.models import SoftDeleteExportableManager
+from django.db.models import F
+
+
+class SegmentManager(SoftDeleteExportableManager):
+    def get_queryset(self):
+        """
+        Returns only the canonical segments, which will always be
+        the highest version.
+        """
+        return super().get_queryset().filter(id=F("version_of"))

api/segments/migrations/0023_add_versioning_to_segments.py

@@ -0,0 +1,58 @@
+# Generated by Django 3.2.25 on 2024-06-10 15:31
+import os
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("segments", "0022_add_soft_delete_to_segment_rules_and_conditions"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="historicalsegment",
+            name="version",
+            field=models.IntegerField(null=True),
+        ),
+        migrations.AddField(
+            model_name="historicalsegment",
+            name="version_of",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="segments.segment",
+            ),
+        ),
+        migrations.AddField(
+            model_name="segment",
+            name="version",
+            field=models.IntegerField(null=True),
+        ),
+        migrations.AddField(
+            model_name="segment",
+            name="version_of",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="versioned_segments",
+                to="segments.segment",
+            ),
+        ),
+        migrations.RunSQL(
+            sql=open(
+                os.path.join(
+                    os.path.dirname(__file__),
+                    "sql",
+                    "0023_add_versioning_to_segments.sql",
+                )
+            ).read(),
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+    ]

api/segments/migrations/sql/0023_add_versioning_to_segments.sql

@@ -0,0 +1 @@
+UPDATE segments_segment SET version_of_id = id;

api/segments/models.py

@@ -1,15 +1,23 @@
 import logging
 import typing
+import uuid
 from copy import deepcopy
 
 from core.models import (
+    SoftDeleteExportableManager,
     SoftDeleteExportableModel,
     abstract_base_auditable_model_factory,
 )
 from django.conf import settings
 from django.contrib.contenttypes.fields import GenericRelation
 from django.core.exceptions import ValidationError
 from django.db import models
+from django_lifecycle import (
+    AFTER_CREATE,
+    BEFORE_CREATE,
+    LifecycleModelMixin,
+    hook,
+)
 from flag_engine.segments import constants
 
 from audit.constants import (
@@ -22,10 +30,13 @@
 from metadata.models import Metadata
 from projects.models import Project
 
+from .managers import SegmentManager
+
 logger = logging.getLogger(__name__)
 
 
 class Segment(
+    LifecycleModelMixin,
     SoftDeleteExportableModel,
     abstract_base_auditable_model_factory(["uuid"]),
 ):
@@ -45,8 +56,25 @@ class Segment(
         Feature, on_delete=models.CASCADE, related_name="segments", null=True
     )
 
+    # This defaults to 1 for newly created segments.
+    version = models.IntegerField(null=True)
+
+    # The related_name is not useful without specifying all_objects as a manager.
+    version_of = models.ForeignKey(
+        "self",
+        on_delete=models.CASCADE,
+        related_name="versioned_segments",
+        null=True,
+        blank=True,
+    )
     metadata = GenericRelation(Metadata)
 
+    # Only serves segments that are the canonical version.
+    objects = SegmentManager()
+
+    # Includes versioned segments.
+    all_objects = SoftDeleteExportableManager()
+
     class Meta:
         ordering = ("id",)  # explicit ordering to prevent pagination warnings
 
@@ -84,6 +112,43 @@ def id_exists_in_rules_data(rules_data: typing.List[dict]) -> bool:
 
         return False
 
+    @hook(BEFORE_CREATE, when="version_of", is_now=None)
+    def set_default_version_to_one_if_new_segment(self):
+        if self.version is None:
+            self.version = 1
+
+    @hook(AFTER_CREATE, when="version_of", is_now=None)
+    def set_version_of_to_self_if_none(self):
+        """
+        This allows the segment model to reference all versions of
+        itself including itself.
+        """
+        self.version_of = self
+        self.save()
+
+    def deep_clone(self) -> "Segment":
+        new_segment = deepcopy(self)
+        new_segment.id = None
+        new_segment.uuid = uuid.uuid4()
+        new_segment.version_of = self
+        new_segment.save()
+
+        self.version += 1
+        self.save()
+
+        new_rules = []
+        for rule in self.rules.all():
+            new_rule = rule.deep_clone(new_segment)
+            new_rules.append(new_rule)
+
+        new_segment.refresh_from_db()
+
+        assert (
+            len(self.rules.all()) == len(new_rules) == len(new_segment.rules.all())
+        ), "Mismatch during rules creation"
+
+        return new_segment
+
     def get_create_log_message(self, history_instance) -> typing.Optional[str]:
         return SEGMENT_CREATED_MESSAGE % self.name
 
@@ -140,6 +205,47 @@ def get_segment(self):
             rule = rule.rule
         return rule.segment
 
+    def deep_clone(self, versioned_segment: Segment) -> "SegmentRule":
+        if self.rule:
+            # Since we're expecting a rule that is only belonging to a
+            # segment, we don't expect there also to be a rule associated.
+            assert False, "Unexpected rule, expecting segment set not rule"
+        new_rule = deepcopy(self)
+        new_rule.segment = versioned_segment
+        new_rule.uuid = uuid.uuid4()
+        new_rule.id = None
+        new_rule.save()
+
+        new_conditions = []
+        for condition in self.conditions.all():
+            new_condition = deepcopy(condition)
+            new_condition.uuid = uuid.uuid4()
+            new_condition.rule = new_rule
+            new_condition.id = None
+            new_conditions.append(new_condition)
+        Condition.objects.bulk_create(new_conditions)
+
+        for sub_rule in self.rules.all():
+            if sub_rule.rules.exists():
+                assert False, "Expected two layers of rules, not more"
+
+            new_sub_rule = deepcopy(sub_rule)
+            new_sub_rule.rule = new_rule
+            new_sub_rule.uuid = uuid.uuid4()
+            new_sub_rule.id = None
+            new_sub_rule.save()
+
+            new_conditions = []
+            for condition in sub_rule.conditions.all():
+                new_condition = deepcopy(condition)
+                new_condition.rule = new_sub_rule
+                new_condition.uuid = uuid.uuid4()
+                new_condition.id = None
+                new_conditions.append(new_condition)
+            Condition.objects.bulk_create(new_conditions)
+
+        return new_rule
+
 
 class Condition(
     SoftDeleteExportableModel, abstract_base_auditable_model_factory(["uuid"])

api/segments/serializers.py

@@ -81,11 +81,15 @@ def create(self, validated_data):
         self._update_or_create_metadata(metadata_data, segment=segment)
         return segment
 
-    def update(self, instance, validated_data):
+    def update(self, instance: Segment, validated_data: dict[str, typing.Any]) -> None:
         # use the initial data since we need the ids included to determine which to update & which to create
         rules_data = self.initial_data.pop("rules", [])
         metadata_data = validated_data.pop("metadata", [])
         self.validate_segment_rules_conditions_limit(rules_data)
+
+        # Create a version of the segment now that we're updating.
+        instance.deep_clone()
+
         self._update_segment_rules(rules_data, segment=instance)
         self._update_or_create_metadata(metadata_data, segment=instance)
         # remove rules from validated data to prevent error trying to create segment with nested rules

api/tests/integration/audit/test_audit_logs.py

@@ -250,7 +250,7 @@ def test_retrieve_audit_log_includes_changes_when_segment_override_created_and_d
     get_audit_logs_response_2 = admin_client.get(get_audit_logs_url)
     assert get_audit_logs_response_2.status_code == status.HTTP_200_OK
     results = get_audit_logs_response_2.json()["results"]
-    assert len(results) == 5
+    assert len(results) == 6
 
     # and the first one in the list should be for the deletion of the segment override
     delete_override_audit_log_id = results[0]["id"]
@@ -308,9 +308,9 @@ def test_retrieve_audit_log_includes_changes_when_segment_override_created_for_f
 
     # and we should only have one audit log in the list related to the segment override
     # (since the FeatureState hasn't changed)
-    # 1 for creating the feature + 1 for creating the environment + 1 for creating the segment
-    # + 1 for the segment override = 4
-    assert len(results) == 4
+    # 1 for creating the feature + 1 for creating the environment + 2 for creating the segment
+    # + 1 for the segment override = 5
+    assert len(results) == 5
 
     # the first audit log in the list (i.e. most recent) should be the one that we want
     audit_log_id = results[0]["id"]