feat: Sitemap 등록 시 순환 참조 및 중복 등록 방지를 위한 검증 추가

Author: MU-Software

app/cms/models.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
+
+import dataclasses
 import datetime
 import typing
 
 from core.models import BaseAbstractModel, BaseAbstractModelQuerySet
+from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models
 
@@ -15,6 +19,22 @@ def __str__(self):
         return str(self.title)
 
 
+@dataclasses.dataclass
+class SitemapGraph:
+    id: str
+    parent_id: str | None
+    route_code: str
+
+    parent: SitemapGraph | None = None
+    children: list[SitemapGraph] = dataclasses.field(default_factory=list)
+
+    @property
+    def route(self) -> str:
+        if self.parent:
+            return f"{self.parent.route}/{self.route_code}"
+        return self.route_code
+
+
 class SitemapQuerySet(BaseAbstractModelQuerySet):
     def filter_by_today(self) -> typing.Self:
         now = datetime.datetime.now()
@@ -23,10 +43,28 @@ def filter_by_today(self) -> typing.Self:
             models.Q(display_end_at__isnull=True) | models.Q(display_end_at__gte=now),
         )
 
+    def get_all_routes(self) -> set[str]:
+        flattened_graph: dict[str, SitemapGraph] = {
+            id: SitemapGraph(id=id, parent_id=parent_id, route_code=route_code)
+            for id, parent_id, route_code in self.all().values_list("id", "parent_sitemap_id", "route_code")
+        }
+        roots: list[SitemapGraph] = []
+
+        for node in flattened_graph.values():
+            if node.parent_id is None:
+                roots.append(node)
+                continue
+
+            parent_node = flattened_graph[node.parent_id]
+            node.parent = parent_node
+            parent_node.children.append(node)
+
+        return {node.route for node in flattened_graph.values()}
+
 
 class Sitemap(BaseAbstractModel):
     parent_sitemap = models.ForeignKey(
-        "self", null=True, default=None, on_delete=models.SET_NULL, related_name="children"
+        "self", null=True, blank=True, default=None, on_delete=models.SET_NULL, related_name="children"
     )
 
     route_code = models.CharField(max_length=256)
@@ -52,6 +90,22 @@ def route(self) -> str:
             return f"{self.parent_sitemap.route}/{self.route_code}"
         return self.route_code
 
+    def clean(self) -> None:
+        # Parent Sitemap과 Page가 같을 경우 ValidationError 발생
+        if self.parent_sitemap_id and self.parent_sitemap_id == self.id:
+            raise ValidationError("자기 자신을 부모로 설정할 수 없습니다.")
+
+        # 순환 참조를 방지하기 위해 Parent Sitemap이 자식 Sitemap을 가리키는 경우 ValidationError 발생
+        parent_sitemap = self.parent_sitemap
+        while parent_sitemap:
+            if parent_sitemap == self:
+                raise ValidationError("Parent Sitemap이 자식 Sitemap을 가리킬 수 없습니다.")
+            parent_sitemap = parent_sitemap.parent_sitemap
+
+        # route를 계산할 시 이미 존재하는 route가 있을 경우 ValidationError 발생
+        if self.route in Sitemap.objects.get_all_routes():
+            raise ValidationError(f"`{self.route}`라우트는 이미 존재하는 route입니다.")
+
 
 class Section(BaseAbstractModel):
     page = models.ForeignKey(Page, on_delete=models.CASCADE, related_name="sections")

app/cms/test/site_route_calculation_test.py

@@ -1,5 +1,6 @@
 import pytest
 from cms.models import Page, Sitemap
+from django.core.exceptions import ValidationError
 
 
 @pytest.mark.django_db
@@ -31,3 +32,121 @@ def test_route_calculation():
     assert root_sitemap.route == "root"
     assert child_sitemap.route == "root/child"
     assert grandchild_sitemap.route == "root/child/grandchild"
+
+
+@pytest.mark.django_db
+def test_get_all_routes():
+    # Given: nested한 사이트맵 구조 생성
+    data = {
+        "root_1": {
+            "child_1_1": {"child_1_1_1": {}, "child_1_1_2": {}},
+            "child_1_2": {"child_1_2_1": {}},
+            "child_1_3": {},
+        },
+        "root_2": {
+            "child_2_1": {"child_2_1_1": {}},
+            "child_2_2": {},
+        },
+    }
+
+    def create_sitemaps(data: dict[str, dict], parent: Sitemap = None) -> None:
+        for name, children in data.items():
+            sitemap = Sitemap.objects.create(
+                route_code=name,
+                name=name,
+                page=Page.objects.create(title=name, subtitle=f"{name} Subtitle"),
+                parent_sitemap=parent,
+            )
+            create_sitemaps(children, sitemap)
+
+    create_sitemaps(data)
+
+    # When: Sitemap.objects.get_all_routes() 메서드를 호출할 시
+    all_routes = Sitemap.objects.get_all_routes()
+
+    # Then: 예상한 모든 route가 나와야 한다.
+    assert all_routes == {
+        "root_1",
+        "root_1/child_1_1",
+        "root_1/child_1_1/child_1_1_1",
+        "root_1/child_1_1/child_1_1_2",
+        "root_1/child_1_2",
+        "root_1/child_1_2/child_1_2_1",
+        "root_1/child_1_3",
+        "root_2",
+        "root_2/child_2_1",
+        "root_2/child_2_1/child_2_1_1",
+        "root_2/child_2_2",
+    }
+
+
+@pytest.mark.django_db
+def test_clean_should_check_for_self_reference():
+    # Given: Sitemap 객체 생성
+    sitemap = Sitemap.objects.create(
+        route_code="self",
+        name="Self Sitemap",
+        page=Page.objects.create(title="Self Page", subtitle="Self Subtitle"),
+    )
+
+    # When: Self-reference를 만들기 위해 parent_sitemap을 자기 자신으로 설정
+    sitemap.parent_sitemap = sitemap
+
+    # Then: ValidationError가 발생해야 한다.
+    with pytest.raises(ValidationError) as excinfo:
+        sitemap.clean()
+        assert str(excinfo.value) == "자기 자신을 부모로 설정할 수 없습니다."
+
+
+@pytest.mark.django_db
+def test_clean_should_check_for_circular_reference():
+    # Given: Circular reference가 있는 Sitemap 객체 생성
+    root_sitemap = Sitemap.objects.create(
+        route_code="root",
+        name="Root Sitemap",
+        page=Page.objects.create(title="Root Page", subtitle="Root Subtitle"),
+    )
+
+    child_sitemap = Sitemap.objects.create(
+        route_code="child",
+        name="Child Sitemap",
+        parent_sitemap=root_sitemap,
+        page=Page.objects.create(title="Child Page", subtitle="Child Subtitle"),
+    )
+
+    grandchild_sitemap = Sitemap.objects.create(
+        route_code="grandchild",
+        name="Grandchild Sitemap",
+        parent_sitemap=child_sitemap,
+        page=Page.objects.create(title="Grandchild Page", subtitle="Grandchild Subtitle"),
+    )
+
+    # When: Circular reference를 만들기 위해 child_sitemap을 root_sitemap의 parent로 설정
+    root_sitemap.parent_sitemap = grandchild_sitemap
+
+    # Then: ValidationError가 발생해야 한다.
+    with pytest.raises(ValidationError) as excinfo:
+        root_sitemap.clean()
+        assert str(excinfo.value) == "Parent Sitemap이 자식 Sitemap을 가리킬 수 없습니다."
+
+
+@pytest.mark.django_db
+def test_clean_should_check_for_existing_route():
+    # Given: 이미 존재하는 route를 가진 Sitemap 객체 생성
+    Sitemap.objects.create(
+        route_code="existing",
+        name="Existing Sitemap",
+        page=Page.objects.create(title="Existing Page", subtitle="Existing Subtitle"),
+    )
+
+    # When: 새로운 Sitemap 객체를 생성하고, 기존의 route와 같은 route_code를 설정
+    new_sitemap = Sitemap(
+        route_code="existing",
+        name="New Sitemap",
+        page=Page.objects.create(title="New Page", subtitle="New Subtitle"),
+    )
+
+    # Then: ValidationError가 발생해야 한다.
+    with pytest.raises(ValidationError) as excinfo:
+        new_sitemap.clean()
+        assert str(excinfo.value) == "`existing`라우트는 이미 존재하는 route입니다."