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

nautobot/data_validation/forms.py

@@ -15,6 +15,7 @@ from nautobot.core.forms import (
     TagFilterField,
 )
 from nautobot.core.forms.constants import BOOLEAN_WITH_BLANK_CHOICES
+from nautobot.core.utils.config import get_settings_or_config
 from nautobot.data_validation.models import (
     DataCompliance,
     MinMaxValidationRule,
@@ -22,6 +23,8 @@ from nautobot.data_validation.models import (
     RequiredValidationRule,
     UniqueValidationRule,
 )
+from nautobot.dcim.choices import DeviceUniquenessChoices
+from nautobot.dcim.models import Device
 from nautobot.extras.forms import (
     NautobotBulkEditForm,
     NautobotFilterForm,
@@ -300,3 +303,40 @@ class DataComplianceFilterForm(BootstrapMixin, forms.Form):
         required=False,
     )
     q = forms.CharField(required=False, label="Search")
+
+
+#
+# Device Constraints
+#
+
+
+class DeviceConstraintsForm(BootstrapMixin, forms.Form):
+    DEVICE_UNIQUENESS = forms.ChoiceField(
+        choices=DeviceUniquenessChoices.CHOICES,
+        label="Device Uniqueness",
+        required=True,
+        error_messages={
+            "invalid_choice": f"Invalid value. Available options are: {', '.join(DeviceUniquenessChoices.values())}"
+        },
+    )
+    DEVICE_NAME_REQUIRED = forms.BooleanField(
+        label="Device name required (cannot be blank or null)",
+        initial=False,
+        required=False,
+    )
+
+    def __init__(self, *args, user=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.fields["DEVICE_UNIQUENESS"].initial = get_settings_or_config(
+            "DEVICE_UNIQUENESS", fallback=DeviceUniquenessChoices.DEFAULT
+        )
+
+        device_ct = ContentType.objects.get_for_model(Device)
+        name_rule_exists = RequiredValidationRule.objects.filter(content_type=device_ct, field="name").exists()
+
+        self.fields["DEVICE_NAME_REQUIRED"].initial = name_rule_exists
+
+        if user is not None and not user.is_staff:
+            for field in self.fields.values():
+                field.disabled = True

nautobot/data_validation/migrations/0001_initial.py

@@ -198,12 +198,6 @@ class Migration(migrations.Migration):
                         default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True
                     ),
                 ),
-                ("created", models.DateTimeField(auto_now_add=True, null=True)),
-                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
-                (
-                    "_custom_field_data",
-                    models.JSONField(blank=True, default=dict, encoder=django.core.serializers.json.DjangoJSONEncoder),
-                ),
                 ("compliance_class_name", models.CharField(max_length=255)),
                 ("last_validation_date", models.DateTimeField(auto_now=True)),
                 ("object_id", models.UUIDField(blank=False, null=False)),
@@ -216,7 +210,6 @@ class Migration(migrations.Migration):
                     "content_type",
                     models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to="contenttypes.contenttype"),
                 ),
-                ("tags", nautobot.core.models.fields.TagsField(through="extras.TaggedItem", to="extras.Tag")),
             ],
             options={
                 "verbose_name_plural": "Data Compliance",

nautobot/data_validation/migrations/0002_data_migration_from_app.py

@@ -13,7 +13,8 @@ def update_data_validation_engine_job_module_name(apps, schema_editor):
     """
     Job = apps.get_model("extras", "Job")
     dve_jobs = Job.objects.filter(module_name="nautobot_data_validation_engine.jobs")
-    dve_jobs.update(module_name="nautobot.data_validation.jobs")
+    # Now that the DVE jobs are system jobs, they should be enabled by default
+    dve_jobs.update(module_name="nautobot.core.jobs", enabled=True)
 
 
 def update_data_validation_engine_git_repo_contents(apps, schema_editor):
@@ -136,9 +137,6 @@ def copy_app_data_to_core_data(apps, schema_editor):
             f"""\
 INSERT INTO data_validation_datacompliance (
     id,
-    created,
-    last_updated,
-    _custom_field_data,
     compliance_class_name,
     last_validation_date,
     content_type_id,
@@ -150,9 +148,6 @@ INSERT INTO data_validation_datacompliance (
     message
 ) SELECT
     id,
-    created,
-    last_updated,
-    _custom_field_data,
     compliance_class_name,
     last_validation_date,
     content_type_id,
@@ -176,7 +171,7 @@ def revert_data_validation_engine_job_module_name(apps, schema_editor):
     Revert the `module_name` for the Jobs to match the old location of the data validation engine.
     """
     Job = apps.get_model("extras", "Job")
-    dve_jobs = Job.objects.filter(module_name="nautobot.data_validation.jobs")
+    dve_jobs = Job.objects.filter(module_name="nautobot.core.jobs")
     dve_jobs.update(module_name="nautobot_data_validation_engine.jobs")
 
 
@@ -274,9 +269,6 @@ def copy_core_data_to_app_data(apps, schema_editor):
             f"""\
 INSERT INTO nautobot_data_validation_engine_datacompliance (
     id,
-    created,
-    last_updated,
-    _custom_field_data,
     compliance_class_name,
     last_validation_date,
     content_type_id,
@@ -288,9 +280,6 @@ INSERT INTO nautobot_data_validation_engine_datacompliance (
     message
 ) SELECT
     id,
-    created,
-    last_updated,
-    _custom_field_data,
     compliance_class_name,
     last_validation_date,
     content_type_id,

nautobot/data_validation/models.py

@@ -9,10 +9,11 @@ from django.core.validators import MinValueValidator, ValidationError
 from django.db import models
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
-from nautobot.core.models import BaseManager
+from nautobot.core.models import BaseManager, BaseModel
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.models.querysets import RestrictedQuerySet
 from nautobot.core.utils.cache import construct_cache_key
+from nautobot.extras.models.mixins import DynamicGroupsModelMixin, NotesMixin, SavedViewMixin
 from nautobot.extras.utils import extras_features, FeatureQuery
 
 
@@ -62,7 +63,7 @@ class ValidationRuleManager(BaseManager.from_queryset(RestrictedQuerySet)):
         return construct_cache_key(self, method_name="get_enabled_for_model", branch_aware=True)
 
 
-class ValidationRule(PrimaryModel):
+class ValidationRuleModelMixin(models.Model):
     """Base model for all validation engine rule models."""
 
     name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
@@ -83,6 +84,8 @@ class ValidationRule(PrimaryModel):
     objects = ValidationRuleManager()
     documentation_static_path = "docs/user-guide/platform-functionality/data-validation.html"
 
+    is_data_compliance_model = False
+
     class Meta:
         """Model metadata for all validation engine rule models."""
 
@@ -101,7 +104,7 @@ class ValidationRule(PrimaryModel):
     "relationships",
     "webhooks",
 )
-class RegularExpressionValidationRule(ValidationRule):
+class RegularExpressionValidationRule(ValidationRuleModelMixin, PrimaryModel):
     """A type of validation rule that applies a regular expression to a given model field."""
 
     regular_expression = models.TextField()
@@ -165,7 +168,7 @@ class RegularExpressionValidationRule(ValidationRule):
     "relationships",
     "webhooks",
 )
-class MinMaxValidationRule(ValidationRule):
+class MinMaxValidationRule(ValidationRuleModelMixin, PrimaryModel):
     """A type of validation rule that applies min/max constraints to a given numeric model field."""
 
     min = models.FloatField(
@@ -231,7 +234,7 @@ class MinMaxValidationRule(ValidationRule):
     "relationships",
     "webhooks",
 )
-class RequiredValidationRule(ValidationRule):
+class RequiredValidationRule(ValidationRuleModelMixin, PrimaryModel):
     """A type of validation rule that applies a required constraint to a given model field."""
 
     clone_fields = ["enabled", "content_type", "error_message"]
@@ -279,7 +282,7 @@ class RequiredValidationRule(ValidationRule):
     "relationships",
     "webhooks",
 )
-class UniqueValidationRule(ValidationRule):
+class UniqueValidationRule(ValidationRuleModelMixin, PrimaryModel):
     """
     A type of validation rule that applies a unique constraint to a given model field.
 
@@ -321,7 +324,11 @@ class UniqueValidationRule(ValidationRule):
             raise ValidationError({"field": "This field is already unique by default."})
 
 
-class DataCompliance(PrimaryModel):
+@extras_features(
+    "export_templates",
+    "graphql",
+)
+class DataCompliance(DynamicGroupsModelMixin, NotesMixin, SavedViewMixin, BaseModel):
     """Model to represent the results of an audit method."""
 
     compliance_class_name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=False, null=False)
@@ -335,6 +342,8 @@ class DataCompliance(PrimaryModel):
     valid = models.BooleanField(blank=False, null=False)
     message = models.TextField(blank=True, default="")
 
+    is_data_compliance_model = False
+
     class Meta:
         """Meta class for Audit model."""
 

nautobot/data_validation/navigation.py

@@ -1,11 +1,13 @@
 """App navigation menu items."""
 
 from nautobot.apps.ui import NavMenuAddButton, NavMenuGroup, NavMenuItem, NavMenuTab
+from nautobot.core.ui.choices import NavigationIconChoices, NavigationWeightChoices
 
 menu_items = (
     NavMenuTab(
         name="Extensibility",
-        icon="cast",
+        icon=NavigationIconChoices.EXTENSIBILITY,
+        weight=NavigationWeightChoices.EXTENSIBILITY,
         groups=(
             NavMenuGroup(
                 name="Data Validation",
@@ -60,6 +62,11 @@ menu_items = (
                         name="Data Compliance",
                         permissions=["data_validation.view_datacompliance"],
                     ),
+                    NavMenuItem(
+                        link="data_validation:device-constraints",
+                        name="Device Constraints",
+                        permissions=["dcim.view_device"],
+                    ),
                 ),
             ),
         ),

nautobot/data_validation/tables.py

@@ -3,7 +3,7 @@
 from django.utils.html import format_html
 import django_tables2 as tables
 
-from nautobot.core.tables import BaseTable, TagColumn, ToggleColumn
+from nautobot.core.tables import BaseTable, BooleanColumn, TagColumn, ToggleColumn
 from nautobot.data_validation.models import (
     DataCompliance,
     MinMaxValidationRule,
@@ -21,7 +21,9 @@ class RegularExpressionValidationRuleTable(BaseTable):
     """Base table for the RegularExpressionValidationRule model."""
 
     pk = ToggleColumn()
-    name = tables.LinkColumn(order_by=("name",))
+    name = tables.Column(linkify=True, order_by=("name",))
+    enabled = BooleanColumn()
+    context_processing = BooleanColumn()
     tags = TagColumn()
 
     class Meta(BaseTable.Meta):
@@ -60,7 +62,8 @@ class MinMaxValidationRuleTable(BaseTable):
     """Base table for the MinMaxValidationRule model."""
 
     pk = ToggleColumn()
-    name = tables.LinkColumn(order_by=("name",))
+    name = tables.Column(linkify=True, order_by=("name",))
+    enabled = BooleanColumn()
     tags = TagColumn()
 
     class Meta(BaseTable.Meta):
@@ -99,7 +102,8 @@ class RequiredValidationRuleTable(BaseTable):
     """Base table for the RequiredValidationRule model."""
 
     pk = ToggleColumn()
-    name = tables.LinkColumn(order_by=("name",))
+    name = tables.Column(linkify=True, order_by=("name",))
+    enabled = BooleanColumn()
     tags = TagColumn()
 
     class Meta(BaseTable.Meta):
@@ -134,7 +138,8 @@ class UniqueValidationRuleTable(BaseTable):
     """Base table for the UniqueValidationRule model."""
 
     pk = ToggleColumn()
-    name = tables.LinkColumn(order_by=("name",))
+    name = tables.Column(linkify=True, order_by=("name",))
+    enabled = BooleanColumn()
     tags = TagColumn()
 
     class Meta(BaseTable.Meta):
@@ -186,6 +191,7 @@ class DataComplianceTable(BaseTable):
     id = tables.Column(linkify=True, verbose_name="ID")
     validated_object = tables.RelatedLinkColumn()
     validated_attribute = ValidatedAttributeColumn()
+    valid = BooleanColumn()
 
     def order_validated_object(self, queryset, is_descending):
         """Reorder table by string representation of validated_object."""
@@ -226,6 +232,7 @@ class DataComplianceTableTab(BaseTable):
     """Base table for viewing the DataCompliance related to a single object."""
 
     validated_attribute = ValidatedAttributeColumn()
+    valid = BooleanColumn()
 
     class Meta(BaseTable.Meta):
         """Meta class for DataComplianceTableTab."""

nautobot/data_validation/templates/data_validation/datacompliance_tab.html

@@ -1,3 +1,4 @@
+{% comment %}Kept for use with apps that have not transitioned to the new UI Component framework.{% endcomment %}
 {% extends base_template %}
 {% load helpers %}
 {% load tz %}

nautobot/data_validation/templates/data_validation/device_constraints.html

@@ -0,0 +1,61 @@
+{% extends "base.html" %}
+{% load form_helpers %}
+{% load ui_framework %}
+
+{% block breadcrumbs_wrapper %}{% render_breadcrumbs %}{% endblock %}
+
+{% block content %}
+    <form action="." method="post" class="h-100 vstack">
+        {% csrf_token %}
+        <div class="alert alert-warning d-flex align-items-center" role="alert">
+            <span aria-hidden="true" class="mdi mdi-alert me-2"></span>
+            <div>
+                <strong>Warning:</strong> Changes made here affect how device uniqueness and naming rules are enforced.
+                These changes will update the Constance configuration for <code>DEVICE_UNIQUENESS</code> and will create
+                a <code>RequiredValidationRule</code> for the <code>Device</code> model if
+                <i>Device name required</i> is selected.
+                Modify these settings <strong>at your own risk</strong>.
+            </div>
+        </div>
+        <div class="row align-content-start flex-fill">
+            <div class="col-md-8 offset-md-2">
+
+                {% if form.non_field_errors %}
+                    <div class="card border-danger mb-16">
+                        <div class="card-header bg-danger-subtle border-danger text-body">
+                            <strong>Errors</strong>
+                        </div>
+                        <div class="card-body">
+                            {{ form.non_field_errors }}
+                        </div>
+                    </div>
+                {% endif %}
+
+                <div class="card mb-16">
+                    <div class="card-header"><strong>Device Constraints</strong></div>
+                    <div class="card-body">
+                        {% render_field form.DEVICE_UNIQUENESS %}
+                        {% render_field form.DEVICE_NAME_REQUIRED %}
+                        {% if not request.user.is_staff %}
+                            <p class="text-secondary mt-2 text-center">
+                                <em>You do not have permission to modify these settings.</em>
+                            </p>
+                        {% endif %}
+                    </div>
+                </div>
+            </div>
+        </div>
+        <div class="nb-form-sticky-footer">
+            {% if request.user.is_staff %}
+                <button type="submit" name="_update" class="btn btn-primary">
+                    <span aria-hidden="true" class="mdi mdi-check me-4"></span><!--
+                        -->Update
+                </button>
+                <a href="{% url 'home' %}" class="btn btn-secondary">
+                    <span aria-hidden="true" class="mdi mdi-close me-4"></span><!--
+                        -->Cancel
+                </a>
+            {% endif %}
+        </div>
+    </form>
+{% endblock %}

nautobot/data_validation/tests/__init__.py

@@ -5,11 +5,11 @@ import contextlib
 from django.core.cache import cache
 import redis.exceptions
 
-from nautobot.data_validation.models import ValidationRule
+from nautobot.data_validation.models import ValidationRuleModelMixin
 
 
 class ValidationRuleTestCaseMixin:
-    model: type(ValidationRule)
+    model: type(ValidationRuleModelMixin)
 
     def tearDown(self):
         """Ensure that validation rule caches are cleared to avoid leakage into other tests."""

nautobot/data_validation/tests/migrations/test_migrations.py

@@ -210,7 +210,26 @@ CREATE TABLE `nautobot_data_validation_engine_uniquevalidationrule` (
 
 def _populate_tables_postgresql(ContentType, DeviceType, VLAN):
     with connection.cursor() as cursor:
-        # TODO: datacompliance
+        cursor.execute(
+            """\
+INSERT INTO nautobot_data_validation_engine_datacompliance
+VALUES (
+  'f20e4572-84cf-4f28-9fe6-5f0f96f78d14',
+  '2025-10-21 16:07:55.123456+00',
+  '2025-10-21 16:07:55.123456+00',
+  '{}',
+  'DcimDevicetypeCustomValidator',
+  '2025-10-21 16:07:55.123456+00',
+  '96591cd4-c4d1-4d69-982d-195bcea71a2c',
+  'Juniper SRX300',
+  'part_number',
+  '',
+  'f',
+  'A device type may only contain alpha numeric, dashes, and underscore characters.',
+  %s
+);""",
+            [ContentType.objects.get_for_model(DeviceType).id],
+        )
 
         # Min/max validation rules
         cursor.execute(
@@ -269,7 +288,26 @@ VALUES (
 
 def _populate_tables_mysql(ContentType, DeviceType, VLAN):
     with connection.cursor() as cursor:
-        # TODO: datacompliance
+        cursor.execute(
+            """\
+INSERT INTO `nautobot_data_validation_engine_datacompliance`
+VALUES (
+  'f20e457284cf4f289fe65f0f96f78d14',
+  '2025-10-21 16:07:55.123456',
+  '2025-10-21 16:07:55.123456',
+  '{}',
+  'DcimDevicetypeCustomValidator',
+  '2025-10-21 16:07:55.123456',
+  '96591cd4c4d14d69982d195bcea71a2c',
+  'Juniper SRX300',
+  'part_number',
+  '',
+  0,
+  'A device type may only contain alpha numeric, dashes, and underscore characters.',
+  %s
+);""",
+            [ContentType.objects.get_for_model(DeviceType).id],
+        )
 
         # Min/max validation rules
         cursor.execute(
@@ -366,7 +404,7 @@ class DVEToDataValidationMigrationTestCase(MigratorTestCase):
         UniqueValidationRule = self.new_state.apps.get_model("data_validation", "uniquevalidationrule")
 
         with self.subTest("DataCompliance"):
-            self.assertEqual(DataCompliance.objects.count(), 0)
+            self.assertEqual(DataCompliance.objects.count(), 1)
 
         with self.subTest("MinMaxValidationRule"):
             self.assertEqual(MinMaxValidationRule.objects.count(), 1)
@@ -397,6 +435,48 @@ class DataValidationToDVEMigrationTestCase(MigratorTestCase):
         else:
             raise ValueError(f"Unknown/unsupported database vendor {connection.vendor}")
 
+        ContentType = self.old_state.apps.get_model("contenttypes", "contenttype")
+        DeviceType = self.old_state.apps.get_model("dcim", "devicetype")
+        VLAN = self.old_state.apps.get_model("ipam", "vlan")
+
+        DataCompliance = self.old_state.apps.get_model("data_validation", "datacompliance")
+        MinMaxValidationRule = self.old_state.apps.get_model("data_validation", "minmaxvalidationrule")
+        RegularExpressionValidationRule = self.old_state.apps.get_model(
+            "data_validation", "regularexpressionvalidationrule"
+        )
+
+        DataCompliance.objects.create(
+            compliance_class_name="DcimDevicetypeCustomValidator",
+            object_id="96591cd4-c4d1-4d69-982d-195bcea71a2c",
+            validated_object_str="Juniper SRX300",
+            validated_attribute="part_number",
+            validated_attribute_value="",
+            valid=False,
+            message="A device type may only contain alpha numeric, dashes, and underscore characters.",
+            content_type=ContentType.objects.get_for_model(DeviceType),
+        )
+        MinMaxValidationRule.objects.create(
+            name="Max VLAN ID",
+            enabled=False,
+            error_message="",
+            field="vid",
+            min=None,
+            max=3999,
+            content_type=ContentType.objects.get_for_model(VLAN),
+        )
+        RegularExpressionValidationRule.objects.create(
+            name="Device Type Part Number",
+            enabled=True,
+            error_message="A device type may only contain alpha numeric, dashes, and underscore characters.",
+            field="part_number",
+            regular_expression="^[a-zA-Z0-9_-]+$",
+            content_type=ContentType.objects.get_for_model(DeviceType),
+            context_processing=False,
+        )
+
+        # TODO: requiredvalidationrule
+        # TODO: uniquevalidationrule
+
     def tearDown(self):
         super().tearDown()
         if connection.vendor == "postgresql":

nautobot/data_validation/tests/test_data_compliance_rules.py

@@ -19,10 +19,9 @@ class TestFailedDataComplianceRule(DataComplianceRule):
         # attribute
         raise ComplianceError(
             {
-                "tenant": "Tenant",
-                "description": "Description",
-                "name": "Name",
-                "status": "Status",
+                "tenant": "The tenant is wrong",
+                "name": "The name is wrong",
+                "status": "The status is wrong",
             }
         )
 
@@ -36,6 +35,12 @@ class TestPassedDataComplianceRule(DataComplianceRule):
         """No exception means the audit passes."""
 
 
+class TestFailedDataComplianceRuleAlt(TestFailedDataComplianceRule):
+    """Test implementation of DataComplianceRule, for dcim.rack."""
+
+    model = "dcim.device"
+
+
 class TestCompliance(TestCase):
     """Test DataComplianceRule methods."""
 
@@ -62,7 +67,7 @@ class TestCompliance(TestCase):
 
     def test_audit_fail(self):
         result = DataCompliance.objects.filter(valid=False).all()
-        self.assertEqual(len(result), 5)
+        self.assertEqual(len(result), 4)
         result = DataCompliance.objects.get(validated_attribute="tenant")
         self.assertEqual(result.compliance_class_name, "TestFailedDataComplianceRule")
         self.assertEqual(result.validated_object, self.s)
@@ -71,10 +76,10 @@ class TestCompliance(TestCase):
 
     def test_validate_replaces_results(self):
         self.assertEqual(
-            len(DataCompliance.objects.filter(compliance_class_name=TestFailedDataComplianceRule.__name__)), 5
+            len(DataCompliance.objects.filter(compliance_class_name=TestFailedDataComplianceRule.__name__)), 4
         )
         TestFailedDataComplianceRule(self.s).clean()
         self.assertEqual(
             len(DataCompliance.objects.filter(compliance_class_name=TestFailedDataComplianceRule.__name__)),
-            5,
+            4,
         )

nautobot/data_validation/tests/test_filters.py

@@ -40,9 +40,7 @@ class ValidationRuleFilterTestCaseMixin(ValidationRuleTestCaseMixin):
         self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
 
 
-class RegularExpressionValidationRuleFilterTestCase(
-    ValidationRuleFilterTestCaseMixin, FilterTestCases.NameOnlyFilterTestCase
-):
+class RegularExpressionValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.FilterTestCase):
     """
     Filterset test cases for the RegularExpressionValidationRule model
     """
@@ -52,6 +50,7 @@ class RegularExpressionValidationRuleFilterTestCase(
     filterset = RegularExpressionValidationRuleFilterSet
     generic_filter_tests = [
         ("id",),
+        ("name",),
         ("regular_expression",),
         ("error_message",),
         ("field",),
@@ -91,7 +90,7 @@ class RegularExpressionValidationRuleFilterTestCase(
         )
 
 
-class MinMaxValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.NameOnlyFilterTestCase):
+class MinMaxValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.FilterTestCase):
     """
     Filterset test cases for the MinMaxValidationRule model
     """
@@ -101,6 +100,7 @@ class MinMaxValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, Filt
     filterset = MinMaxValidationRuleFilterSet
     generic_filter_tests = [
         ("id",),
+        ("name",),
         ("error_message",),
         ("field",),
     ]
@@ -144,7 +144,7 @@ class MinMaxValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, Filt
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
 
-class RequiredValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.NameOnlyFilterTestCase):
+class RequiredValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.FilterTestCase):
     """
     Filterset test cases for the RequiredValidationRule model
     """
@@ -154,6 +154,7 @@ class RequiredValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, Fi
     filterset = RequiredValidationRuleFilterSet
     generic_filter_tests = [
         ("id",),
+        ("name",),
         ("error_message",),
         ("field",),
     ]
@@ -189,7 +190,7 @@ class RequiredValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, Fi
         )
 
 
-class UniqueValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.NameOnlyFilterTestCase):
+class UniqueValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, FilterTestCases.FilterTestCase):
     """
     Filterset test cases for the UniqueValidationRule model
     """
@@ -199,6 +200,7 @@ class UniqueValidationRuleFilterTestCase(ValidationRuleFilterTestCaseMixin, Filt
     filterset = UniqueValidationRuleFilterSet
     generic_filter_tests = [
         ("id",),
+        ("name",),
         ("error_message",),
         ("field",),
         ("max_instances",),

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)