nautobot 3.0.0a2__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/data_validation/tests/test_models.py

@@ -3,6 +3,7 @@ Model test cases
 """
 
 import re
+from unittest import TestCase
 
 from django.contrib.contenttypes.models import ContentType
 from django.core.validators import ValidationError
@@ -376,3 +377,17 @@ class UniqueValidationRuleModelTestCase(ValidationRuleModelTestCases.ValidationR
             )
 
             rule.clean()
+
+
+class ValidationRuleModelMixinTestCase(TestCase):
+    """
+    Validate ValidationRuleModelMixin is working as intended.
+    """
+
+    def test_is_data_compliance_model(self):
+        """Validate is_data_compliance_model is set correctly on models using ValidationRuleModelMixin."""
+        # These models should have is_data_compliance_model = False
+        self.assertFalse(MinMaxValidationRule.is_data_compliance_model)
+        self.assertFalse(RegularExpressionValidationRule.is_data_compliance_model)
+        self.assertFalse(RequiredValidationRule.is_data_compliance_model)
+        self.assertFalse(UniqueValidationRule.is_data_compliance_model)

nautobot/data_validation/tests/test_views.py

@@ -1,10 +1,13 @@
 """Unit tests for data_validation views."""
 
-from unittest.mock import MagicMock, patch
-
+from constance import config
+from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
-from django.http.request import QueryDict
+from django.core.cache import caches
+from django.test import override_settings
+from django.urls import reverse
 
+from nautobot.core import settings
 from nautobot.core.testing import TestCase, ViewTestCases
 from nautobot.data_validation.models import (
     DataCompliance,
@@ -13,13 +16,17 @@ from nautobot.data_validation.models import (
     RequiredValidationRule,
     UniqueValidationRule,
 )
-from nautobot.data_validation.tables import DataComplianceTableTab
 from nautobot.data_validation.tests import ValidationRuleTestCaseMixin
-from nautobot.data_validation.tests.test_data_compliance_rules import TestFailedDataComplianceRule
-from nautobot.data_validation.views import DataComplianceObjectView
+from nautobot.data_validation.tests.test_data_compliance_rules import (
+    TestFailedDataComplianceRule,
+    TestFailedDataComplianceRuleAlt,
+)
+from nautobot.dcim.choices import DeviceUniquenessChoices
 from nautobot.dcim.models import Device, Location, LocationType, PowerFeed
 from nautobot.extras.models import Status
 
+User = get_user_model()
+
 
 class RegularExpressionValidationRuleTestCase(ValidationRuleTestCaseMixin, ViewTestCases.PrimaryObjectViewTestCase):
     """View test cases for the RegularExpressionValidationRule model."""
@@ -247,31 +254,182 @@ class DataComplianceObjectTestCase(TestCase):
     """Test cases for DataComplianceObjectView."""
 
     def setUp(self):
-        location_type = LocationType(name="Region")
-        location_type.validated_save()
-        s = Location(
-            name="Test Location 1",
-            location_type=LocationType.objects.get_by_natural_key("Region"),
-            status=Status.objects.get_by_natural_key("Active"),
-        )
-        s.save()
-        t = TestFailedDataComplianceRule(s)
+        self.device = Device.objects.first()
+
+        t = TestFailedDataComplianceRuleAlt(self.device)
         t.clean()
+        self.user = User.objects.create_user(username="testuser", is_superuser=True)
+
+    def test_data_compliance_action(self):
+        self.add_permissions("data_validation.view_datacompliance")
+        self.client.force_login(self.user)
+        url = reverse("dcim:device_data-compliance", kwargs={"pk": self.device.pk})
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("active_tab", response.context)
+        self.assertEqual(response.context["active_tab"], "data_compliance")
+        self.assertBodyContains(response, "The tenant is wrong")
+        self.assertBodyContains(response, "The name is wrong")
+        self.assertBodyContains(response, "The status is wrong")
+
+
+class DeviceConstraintsViewTest(TestCase):
+    """Tests for the DeviceConstraintsView."""
 
-    def test_get_extra_context(self):
-        view = DataComplianceObjectView()
-        location = Location.objects.first()
-        mock_request = MagicMock()
-        mock_request.GET = QueryDict("tab=data_validation:1")
-        result = view.get_extra_context(mock_request, location)
-        self.assertEqual(result["active_tab"], "data_validation:1")
-        self.assertIsInstance(result["table"], DataComplianceTableTab)
-
-    @patch("nautobot.core.views.generic.ObjectView.dispatch")
-    def test_dispatch(self, mocked_dispatch):
-        view = DataComplianceObjectView()
-        mock_request = MagicMock()
-        kwargs = {"model": "dcim.location", "other_arg": "other_arg", "another_arg": "another_arg"}
-        view.dispatch(mock_request, **kwargs)
-        mocked_dispatch.assert_called()
-        mocked_dispatch.assert_called_with(mock_request, other_arg="other_arg", another_arg="another_arg")
+    def setUp(self):
+        self.initial_setting = config.DEVICE_UNIQUENESS
+        self.url = reverse("data_validation:device-constraints")
+        self.device_ct = ContentType.objects.get_for_model(Device)
+
+    def tearDown(self):
+        """Reset Constance config and clear cache."""
+        config.DEVICE_UNIQUENESS = self.initial_setting
+        cache = caches[settings.CONSTANCE_DATABASE_CACHE_BACKEND]
+        cache.clear()
+
+    @override_settings(
+        DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE,
+    )
+    def test_page_reflects_correct_settings_for_non_staff(self):
+        """Non-staff view still shows the actual configuration, but in disabled form."""
+        user = get_user_model().objects.create_user(username="testuser")
+        self.client.force_login(user)
+        response = self.client.get(self.url)
+
+        self.assertEqual(response.status_code, 200)
+
+        # Ensure fields are disabled but reflect correct config values
+        self.assertContains(response, f'value="{DeviceUniquenessChoices.NONE}" selected')
+        self.assertContains(response, "disabled")
+        self.assertContains(response, "You do not have permission to modify these settings.")
+
+        # DEVICE_NAME_REQUIRED should NOT be checked, because RequiredValidationRule not exist
+        device_ct = ContentType.objects.get_for_model(Device)
+        self.assertFalse(RequiredValidationRule.objects.filter(content_type=device_ct, field="name").exists())
+        self.assertNotContains(response, 'name="DEVICE_NAME_REQUIRED" checked')
+
+        # Footer buttons should NOT be rendered
+        self.assertNotContains(response, '<button type="submit"')
+        self.assertNotContains(response, "-->Update")
+        self.assertNotContains(response, "-->Cancel")
+
+    @override_settings(
+        DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME,
+    )
+    def test_page_reflects_correct_settings_for_staff(self):
+        """Page should reflect the true values of DEVICE_UNIQUENESS and DEVICE_NAME_REQUIRED."""
+        # Create RequiredValidationRule to check proper value of DEVICE_NAME_REQUIRED
+        device_ct = ContentType.objects.get_for_model(Device)
+        RequiredValidationRule.objects.create(
+            name="Required Name rule",
+            content_type=device_ct,
+            field="name",
+        )
+        user = get_user_model().objects.create_user(username="testuser", is_staff=True)
+        self.client.force_login(user)
+        response = self.client.get(self.url)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "data_validation/device_constraints.html")
+
+        self.assertIn("form", response.context)
+        self.assertContains(response, "Device Constraints")
+
+        # Check that the correct DEVICE_UNIQUENESS option is selected
+        self.assertContains(response, f'value="{DeviceUniquenessChoices.NAME}" selected')
+
+        self.assertNotContains(response, "disabled")
+        self.assertNotContains(response, "You do not have permission to modify these settings.")
+
+        # Check that DEVICE_NAME_REQUIRED checkbox is checked when RequiredValidationRule exist
+        self.assertTrue(RequiredValidationRule.objects.filter(content_type=device_ct, field="name").exists())
+        self.assertContains(response, 'id="id_DEVICE_NAME_REQUIRED" checked')
+
+        # Footer buttons should be rendered
+        self.assertContains(response, '<button type="submit"')
+        self.assertContains(response, "-->Update")
+        self.assertContains(response, "-->Cancel")
+
+    def test_post_as_non_admin_denied(self):
+        """POST by non-admin should be denied."""
+        user = get_user_model().objects.create_user(username="normaluser")
+        self.client.force_login(user)
+
+        response = self.client.post(
+            self.url,
+            data={
+                "DEVICE_UNIQUENESS": DeviceUniquenessChoices.LOCATION_TENANT_NAME,
+                "DEVICE_NAME_REQUIRED": True,
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 403)
+
+        # No rule should be created
+        self.assertFalse(RequiredValidationRule.objects.filter(content_type=self.device_ct, field="name").exists())
+        self.assertEqual(config.DEVICE_UNIQUENESS, self.initial_setting)
+
+    def test_post_updates_device_uniqueness_and_creates_required_rule(self):
+        """POST with DEVICE_NAME_REQUIRED=True should create a RequiredValidationRule."""
+        user = get_user_model().objects.create_user(username="testuser", is_staff=True)
+        self.client.force_login(user)
+        response = self.client.post(
+            self.url,
+            {
+                "DEVICE_UNIQUENESS": DeviceUniquenessChoices.NAME,
+                "DEVICE_NAME_REQUIRED": True,
+            },
+            follow=True,
+        )
+
+        self.assertRedirects(response, self.url)
+        self.assertEqual(config.DEVICE_UNIQUENESS, "name")
+
+        rule_exists = RequiredValidationRule.objects.filter(
+            content_type=self.device_ct,
+            field="name",
+        ).exists()
+        self.assertTrue(rule_exists)
+
+    def test_post_disables_required_rule(self):
+        """POST with DEVICE_NAME_REQUIRED=False should delete the RequiredValidationRule."""
+        user = get_user_model().objects.create_user(username="testuser", is_staff=True)
+        self.client.force_login(user)
+        RequiredValidationRule.objects.create(
+            name="Required Name rule",
+            content_type=self.device_ct,
+            field="name",
+        )
+        self.assertTrue(RequiredValidationRule.objects.filter(content_type=self.device_ct, field="name").exists())
+
+        response = self.client.post(
+            self.url,
+            {
+                "DEVICE_UNIQUENESS": DeviceUniquenessChoices.LOCATION_TENANT_NAME,
+                "DEVICE_NAME_REQUIRED": False,
+            },
+            follow=True,
+        )
+        self.assertRedirects(response, self.url)
+        self.assertEqual(config.DEVICE_UNIQUENESS, DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+
+        self.assertFalse(RequiredValidationRule.objects.filter(content_type=self.device_ct, field="name").exists())
+
+    def test_invalid_post_rerenders_form(self):
+        """If form is invalid, the view should re-render without redirect for multiple invalid inputs."""
+        user = get_user_model().objects.create_user(username="testuser", is_staff=True)
+        self.client.force_login(user)
+
+        invalid_inputs = [
+            {"DEVICE_UNIQUENESS": ""},
+            {"DEVICE_UNIQUENESS": "invalid_value"},
+        ]
+
+        for post_data in invalid_inputs:
+            with self.subTest(post_data=post_data):
+                response = self.client.post(self.url, post_data)
+                self.assertEqual(response.status_code, 200)
+                self.assertTemplateUsed(response, "data_validation/device_constraints.html")
+                self.assertIn("form", response.context)
+                self.assertTrue(response.context["form"].errors)
+                self.assertEqual(config.DEVICE_UNIQUENESS, self.initial_setting)

nautobot/data_validation/urls.py

@@ -15,10 +15,7 @@ router.register("required-rules", views.RequiredValidationRuleUIViewSet)
 router.register("unique-rules", views.UniqueValidationRuleUIViewSet)
 
 urlpatterns = [
-    path(
-        "data-compliance/<model>/<uuid:id>/",
-        views.DataComplianceObjectView.as_view(),
-        name="data-compliance-tab",
-    ),
+    path("device-constraints/", views.DeviceConstraintsView.as_view(), name="device-constraints"),
 ]
+
 urlpatterns += router.urls

nautobot/data_validation/views.py

@@ -1,15 +1,17 @@
 """Views for data_validation."""
 
-from django.apps import apps as global_apps
+from constance import config
+from django.contrib import messages
 from django.contrib.contenttypes.models import ContentType
-from django_tables2 import RequestConfig
+from django.shortcuts import redirect, render
 
+from nautobot.apps.ui import Breadcrumbs, Titles, ViewNameBreadcrumbItem
 from nautobot.core.ui.choices import SectionChoices
 from nautobot.core.ui.object_detail import (
     ObjectDetailContent,
     ObjectFieldsPanel,
 )
-from nautobot.core.views.generic import ObjectView
+from nautobot.core.views.generic import GenericView
 from nautobot.core.views.mixins import (
     ObjectBulkDestroyViewMixin,
     ObjectChangeLogViewMixin,
@@ -18,18 +20,10 @@ from nautobot.core.views.mixins import (
     ObjectListViewMixin,
     ObjectNotesViewMixin,
 )
-from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.viewsets import NautobotUIViewSet
-from nautobot.data_validation import filters, forms, tables
+from nautobot.data_validation import filters, forms, models, tables
 from nautobot.data_validation.api import serializers
-from nautobot.data_validation.models import (
-    DataCompliance,
-    MinMaxValidationRule,
-    RegularExpressionValidationRule,
-    RequiredValidationRule,
-    UniqueValidationRule,
-)
-from nautobot.extras.utils import get_base_template
+from nautobot.dcim.models import Device
 
 #
 # RegularExpressionValidationRules
@@ -43,7 +37,7 @@ class RegularExpressionValidationRuleUIViewSet(NautobotUIViewSet):
     filterset_class = filters.RegularExpressionValidationRuleFilterSet
     filterset_form_class = forms.RegularExpressionValidationRuleFilterForm
     form_class = forms.RegularExpressionValidationRuleForm
-    queryset = RegularExpressionValidationRule.objects.all()
+    queryset = models.RegularExpressionValidationRule.objects.all()
     serializer_class = serializers.RegularExpressionValidationRuleSerializer
     table_class = tables.RegularExpressionValidationRuleTable
     object_detail_content = ObjectDetailContent(
@@ -69,7 +63,7 @@ class MinMaxValidationRuleUIViewSet(NautobotUIViewSet):
     filterset_class = filters.MinMaxValidationRuleFilterSet
     filterset_form_class = forms.MinMaxValidationRuleFilterForm
     form_class = forms.MinMaxValidationRuleForm
-    queryset = MinMaxValidationRule.objects.all()
+    queryset = models.MinMaxValidationRule.objects.all()
     serializer_class = serializers.MinMaxValidationRuleSerializer
     table_class = tables.MinMaxValidationRuleTable
     object_detail_content = ObjectDetailContent(
@@ -95,7 +89,7 @@ class RequiredValidationRuleUIViewSet(NautobotUIViewSet):
     filterset_class = filters.RequiredValidationRuleFilterSet
     filterset_form_class = forms.RequiredValidationRuleFilterForm
     form_class = forms.RequiredValidationRuleForm
-    queryset = RequiredValidationRule.objects.all()
+    queryset = models.RequiredValidationRule.objects.all()
     serializer_class = serializers.RequiredValidationRuleSerializer
     table_class = tables.RequiredValidationRuleTable
     object_detail_content = ObjectDetailContent(
@@ -121,7 +115,7 @@ class UniqueValidationRuleUIViewSet(NautobotUIViewSet):
     filterset_class = filters.UniqueValidationRuleFilterSet
     filterset_form_class = forms.UniqueValidationRuleFilterForm
     form_class = forms.UniqueValidationRuleForm
-    queryset = UniqueValidationRule.objects.all()
+    queryset = models.UniqueValidationRule.objects.all()
     serializer_class = serializers.UniqueValidationRuleSerializer
     table_class = tables.UniqueValidationRuleTable
     object_detail_content = ObjectDetailContent(
@@ -151,7 +145,7 @@ class DataComplianceUIViewSet(  # pylint: disable=W0223
     """Views for the DataComplianceUIViewSet model."""
 
     lookup_field = "pk"
-    queryset = DataCompliance.objects.all()
+    queryset = models.DataCompliance.objects.all()
     table_class = tables.DataComplianceTable
     filterset_class = filters.DataComplianceFilterSet
     filterset_form_class = forms.DataComplianceFilterForm
@@ -162,33 +156,72 @@ class DataComplianceUIViewSet(  # pylint: disable=W0223
             ObjectFieldsPanel(
                 section=SectionChoices.LEFT_HALF,
                 weight=100,
-                fields="__all__",
+                fields=[
+                    "content_type",
+                    "compliance_class_name",
+                    "last_validation_date",
+                    "validated_object",
+                    "validated_attribute",
+                    "validated_attribute_value",
+                    "valid",
+                    "message",
+                ],
             ),
         )
     )
 
 
-class DataComplianceObjectView(ObjectView):
-    """View for the Audit Results tab dynamically generated on specific object detail views."""
-
-    template_name = "data_validation/datacompliance_tab.html"
-    queryset = None
-
-    def dispatch(self, request, *args, **kwargs):
-        """Set the queryset for the given object and call the inherited dispatch method."""
-        model = kwargs.pop("model")
-        if not self.queryset:
-            self.queryset = global_apps.get_model(model).objects.all()
-        return super().dispatch(request, *args, **kwargs)
+class DeviceConstraintsView(GenericView):
+    template_name = "data_validation/device_constraints.html"
+    view_titles = Titles(titles={"*": "Device Constraints"})
+    breadcrumbs = Breadcrumbs(
+        items={
+            "*": [
+                ViewNameBreadcrumbItem(view_name="data_validation:device-constraints", label="Device Constraints"),
+            ],
+        },
+    )
 
-    def get_extra_context(self, request, instance):
-        """Generate extra context for rendering the DataComplianceObjectView template."""
-        compliance_objects = DataCompliance.objects.filter(
-            content_type=ContentType.objects.get_for_model(instance), object_id=instance.id
+    def get(self, request):
+        form = forms.DeviceConstraintsForm(user=request.user)
+        return render(
+            request,
+            self.template_name,
+            {
+                "form": form,
+                "view_titles": self.get_view_titles(),
+                "breadcrumbs": self.get_breadcrumbs(),
+            },
         )
-        compliance_table = tables.DataComplianceTableTab(compliance_objects)
-        base_template = get_base_template(None, instance)
 
-        paginate = {"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
-        RequestConfig(request, paginate).configure(compliance_table)
-        return {"active_tab": request.GET["tab"], "table": compliance_table, "base_template": base_template}
+    def post(self, request):
+        if not request.user.is_staff:
+            return self.handle_no_permission()
+        form = forms.DeviceConstraintsForm(request.POST)
+        if form.is_valid():
+            config.DEVICE_UNIQUENESS = form.cleaned_data["DEVICE_UNIQUENESS"]
+            device_ct = ContentType.objects.get_for_model(Device)
+            if form.cleaned_data["DEVICE_NAME_REQUIRED"]:
+                models.RequiredValidationRule.objects.get_or_create(
+                    content_type=device_ct,
+                    field="name",
+                    defaults={"name": "Require Device Name"},
+                )
+            else:
+                models.RequiredValidationRule.objects.filter(
+                    content_type=device_ct,
+                    field="name",
+                ).delete()
+
+            messages.success(request, "Device constraints have been updated successfully.")
+            return redirect("data_validation:device-constraints")
+
+        return render(
+            request,
+            self.template_name,
+            {
+                "form": form,
+                "view_titles": self.get_view_titles(),
+                "breadcrumbs": self.get_breadcrumbs(),
+            },
+        )

nautobot/dcim/api/serializers.py

@@ -23,7 +23,6 @@ from nautobot.core.api.utils import (
 )
 from nautobot.core.models.utils import get_all_concrete_models
 from nautobot.core.utils.config import get_settings_or_config
-from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.dcim.choices import (
     CableLengthUnitChoices,
     CableTypeChoices,
@@ -137,12 +136,6 @@ class CableTerminationModelSerializerMixin(serializers.ModelSerializer):
         return None
 
 
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(CableTerminationModelSerializerMixin)
-class CableTerminationSerializer(CableTerminationModelSerializerMixin):
-    pass
-
-
 class PathEndpointModelSerializerMixin(ValidatedModelSerializer):
     connected_endpoint_type = serializers.SerializerMethodField(read_only=True)
     connected_endpoint = serializers.SerializerMethodField(read_only=True)
@@ -183,12 +176,6 @@ class PathEndpointModelSerializerMixin(ValidatedModelSerializer):
         return None
 
 
-# TODO: remove in 2.2
-@class_deprecated_in_favor_of(PathEndpointModelSerializerMixin)
-class ConnectedEndpointSerializer(PathEndpointModelSerializerMixin):
-    pass
-
-
 class ModularDeviceComponentTemplateSerializerMixin:
     def validate(self, data):
         """Validate device_type and module_type field constraints for modular device component templates."""

nautobot/dcim/apps.py

@@ -1,4 +1,5 @@
 from nautobot.core.apps import NautobotConfig
+from nautobot.extras.plugins import register_custom_validators
 
 
 class DCIMConfig(NautobotConfig):
@@ -26,4 +27,7 @@ class DCIMConfig(NautobotConfig):
 
     def ready(self):
         super().ready()
+        from nautobot.dcim.custom_validators import custom_validators
+
+        register_custom_validators(custom_validators)
         import nautobot.dcim.signals  # noqa: F401  # unused-import -- but this import installs the signals

nautobot/dcim/choices.py

@@ -159,6 +159,20 @@ class DeviceStatusChoices(ChoiceSet):
     )
 
 
+class DeviceUniquenessChoices(ChoiceSet):
+    LOCATION_TENANT_NAME = "location_tenant_name"
+    NAME = "name"
+    NONE = "none"
+
+    DEFAULT = LOCATION_TENANT_NAME
+
+    CHOICES = [
+        (LOCATION_TENANT_NAME, "Location + Tenant + Name"),
+        (NAME, "Device name must be globally unique"),
+        (NONE, "No enforced uniqueness"),
+    ]
+
+
 #
 # ConsolePorts
 #
@@ -764,6 +778,7 @@ class InterfaceTypeChoices(ChoiceSet):
     TYPE_VIRTUAL = "virtual"
     TYPE_BRIDGE = "bridge"
     TYPE_LAG = "lag"
+    TYPE_TUNNEL = "tunnel"
 
     # Ethernet
     TYPE_100ME_FX = "100base-fx"
@@ -932,6 +947,7 @@ class InterfaceTypeChoices(ChoiceSet):
                 (TYPE_VIRTUAL, "Virtual"),
                 (TYPE_BRIDGE, "Bridge"),
                 (TYPE_LAG, "Link Aggregation Group (LAG)"),
+                (TYPE_TUNNEL, "Tunnel"),
             ),
         ),
         (

nautobot/dcim/custom_validators.py

@@ -0,0 +1,84 @@
+from django.contrib.contenttypes.models import ContentType
+
+from nautobot.apps.models import CustomValidator
+from nautobot.core.utils.config import get_settings_or_config
+from nautobot.data_validation.models import RequiredValidationRule
+from nautobot.dcim.choices import DeviceUniquenessChoices
+from nautobot.dcim.models import Device
+
+
+class DeviceUniquenessValidator(CustomValidator):
+    """Custom validator enforcing device uniqueness based on DEVICE_UNIQUENESS setting."""
+
+    model = "dcim.device"
+
+    def clean(self):
+        obj = self.context["object"]
+        try:
+            uniqueness_mode = get_settings_or_config("DEVICE_UNIQUENESS", fallback=DeviceUniquenessChoices.DEFAULT)
+        except AttributeError:
+            uniqueness_mode = DeviceUniquenessChoices.DEFAULT
+        device_name_required = RequiredValidationRule.objects.filter(
+            content_type=ContentType.objects.get_for_model(Device), field="name"
+        ).exists()
+
+        # Rule 1: If we don't set DEVICE_NAME_REQUIRED then it's acceptable for any number of devices to be "unnamed",
+        # regardless of the DEVICE_UNIQUENESS setting. Note that we consider both `None` and `""` to be "unnamed".
+        if not obj.name and not device_name_required:
+            return
+
+        # If not obj.name and device_name_required, this will be detected by RequiredValidationRule.
+
+        if uniqueness_mode == DeviceUniquenessChoices.LOCATION_TENANT_NAME:
+            # Rule 2: name is not None, tenant is None, given location --> no duplicates
+            # Rule 3: tenant is None, name is duplicated --> error
+            if obj.tenant is None:
+                duplicates = Device.objects.filter(
+                    name=obj.name,
+                    tenant__isnull=True,
+                    location=obj.location,
+                ).exclude(pk=obj.pk)
+                if duplicates.exists():
+                    self.validation_error(
+                        {
+                            "__all__": (
+                                f"A device named '{obj.name}' with no tenant already exists in this location: {obj.location}. "
+                                "Device names must be unique when tenant is None and DEVICE_UNIQUENESS='location_tenant_name'."
+                            )
+                        }
+                    )
+            else:
+                # When tenant is set, enforce uniqueness per (location, tenant, name)
+                duplicates = Device.objects.filter(
+                    name=obj.name,
+                    tenant=obj.tenant,
+                    location=obj.location,
+                ).exclude(pk=obj.pk)
+                if duplicates.exists():
+                    self.validation_error(
+                        {
+                            "__all__": (
+                                f"A device named '{obj.name}' already exists in this location: {obj.location} and tenant: {obj.tenant}. "
+                                "Device names must be unique per (Location, Tenant) when DEVICE_UNIQUENESS='location_tenant_name'."
+                            )
+                        }
+                    )
+
+        elif uniqueness_mode == DeviceUniquenessChoices.NAME:
+            duplicates = Device.objects.filter(name=obj.name).exclude(pk=obj.pk)
+            if duplicates.exists():
+                self.validation_error(
+                    {
+                        "name": (
+                            f"At least one other device named '{obj.name}' already exists. "
+                            "Device names must be globally unique when DEVICE_UNIQUENESS='name'."
+                        )
+                    }
+                )
+
+        elif uniqueness_mode == "none":
+            # Explicitly no uniqueness enforcement
+            return
+
+
+custom_validators = [DeviceUniquenessValidator]