nautobot 3.0.3__py3-none-any.whl → 3.0.5__py3-none-any.whl

nautobot/extras/tables.py

@@ -374,11 +374,11 @@ class ApprovalWorkflowStageTable(BaseTable):
     actions_needed = tables.TemplateColumn(
         template_code="""
         {% if record.remaining_approvals == 1 %}
-        {{ record.remaining_approvals }} more approval needed
+            {{ record.remaining_approvals }} more approval needed
         {% elif record.remaining_approvals == 0 %}
-        <span class="text-secondary">&mdash;</span>
+            <span class="text-secondary">&mdash;</span>
         {% else %}
-        {{ record.remaining_approvals }} more approvals needed
+            {{ record.remaining_approvals }} more approvals needed
         {% endif %}
         """,
         orderable=False,

nautobot/extras/templates/extras/inc/jobresult_js.html

@@ -10,5 +10,4 @@
     var job_result_id = "{{ result.pk }}";
 
 </script>
-<script src="{% versioned_static 'js/job_result.js' %}"
-        onerror="window.location='{% url 'media_failure' %}?filename=js/job_result.js'"></script>
+<script src="{% versioned_static 'js/job_result.js' %}" onerror="nb.media.handleFailure(this)"></script>

nautobot/extras/templates/extras/scheduledjob.html

@@ -143,7 +143,9 @@
                         <td>{% if value is None %}–{% else %}<code>{{ value }}</code>{% endif %}</td>
                     </tr>
                 {% empty %}
-                    <tr><td>—</td></tr>
+                    <tr>
+                        <td><span class="text-secondary">&mdash;</span></td>
+                    </tr>
                 {% endfor %}
             </table>
         </div>

nautobot/extras/tests/test_customfields.py

@@ -2338,6 +2338,22 @@ class CustomFieldTableTest(TestCase):
         cf_multi_select.default = ["Foo", "Bar"]
         cf_multi_select.validated_save()
 
+        # JSON custom field
+        cf_json = CustomField(
+            type=CustomFieldTypeChoices.TYPE_JSON,
+            label="JSON Field",
+        )
+        cf_json.validated_save()
+        cf_json.content_types.set([content_type])
+
+        # Markdown custom field
+        cf_markdown = CustomField(
+            type=CustomFieldTypeChoices.TYPE_MARKDOWN,
+            label="Markdown Field",
+        )
+        cf_markdown.validated_save()
+        cf_markdown.content_types.set([content_type])
+
         statuses = Status.objects.get_for_model(Location)
 
         # Create a location
@@ -2346,7 +2362,7 @@ class CustomFieldTableTest(TestCase):
             name="Location Custom", status=statuses.first(), location_type=location_type
         )
 
-        # Assign custom field values for location 2
+        # Assign custom field values for location
         self.location._custom_field_data = {
             cf_text.key: "bar",
             cf_integer.key: 456,
@@ -2355,16 +2371,39 @@ class CustomFieldTableTest(TestCase):
             cf_url.key: "http://example.com/2",
             cf_select.key: "Bar",
             cf_multi_select.key: ["Bar", "Baz"],
+            cf_json.key: {"hello": "world"},
+            cf_markdown.key: "## Heading",
         }
         self.location.validated_save()
 
+        # Create a second location
+        self.location_2 = Location.objects.create(
+            name="Location Custom 2", status=statuses.first(), location_type=location_type
+        )
+
+        # Assign custom field values for location 2
+        self.location_2._custom_field_data = {
+            cf_text.key: "<script></script>",
+            cf_integer.key: 0,
+            cf_boolean.key: False,
+            cf_date.key: None,
+            cf_url.key: "",
+            cf_select.key: None,
+            cf_multi_select.key: [],
+            cf_json.key: {},
+            cf_markdown.key: "",
+        }
+        self.location_2.validated_save()
+
+        self.maxDiff = None
+
     def test_custom_field_table_render(self):
-        queryset = Location.objects.filter(name=self.location.name)
+        queryset = Location.objects.filter(name__in=[self.location.name, self.location_2.name])
         location_table = LocationTable(queryset)
 
         custom_column_expected = {
             "text_field": "bar",
-            "number_field": "456",
+            "number_field": 456,
             "boolean_field": '<span class="text-success"><i class="mdi mdi-check-bold" title="Yes"></i></span>',
             "date_field": "2020-01-02",
             "url_field": '<a href="http://example.com/2">http://example.com/2</a>',
@@ -2372,18 +2411,45 @@ class CustomFieldTableTest(TestCase):
             "multi_choice_field": (
                 '<span class="badge bg-secondary">Bar</span> <span class="badge bg-secondary">Baz</span>'
             ),
+            "json_field": '<pre><code class="language-json">{\n&quot;hello&quot;: &quot;world&quot;\n}</code></pre>',
+            "markdown_field": "<h2>Heading</h2>",
         }
 
         bound_row = location_table.rows[0]
 
         for col_name, col_expected_value in custom_column_expected.items():
-            internal_col_name = "cf_" + col_name
-            custom_column = location_table.base_columns.get(internal_col_name)
-            self.assertIsNotNone(custom_column, internal_col_name)
-            self.assertIsInstance(custom_column, CustomFieldColumn)
+            with self.subTest(col_name=col_name, col_expected_value=col_expected_value):
+                internal_col_name = "cf_" + col_name
+                custom_column = location_table.base_columns.get(internal_col_name)
+                self.assertIsNotNone(custom_column, internal_col_name)
+                self.assertIsInstance(custom_column, CustomFieldColumn)
+
+                rendered_value = bound_row.get_cell(internal_col_name)  # pylint: disable=no-member
+                self.assertHTMLEqual(str(rendered_value), str(col_expected_value))
+
+        custom_column_expected_2 = {
+            "text_field": "<script></script>",
+            "number_field": 0,
+            "boolean_field": '<span class="text-danger"><i class="mdi mdi-close-thick" title="No"></i></span>',
+            "date_field": '<span class="text-secondary">&mdash;</span>',
+            "url_field": '<span class="text-secondary">&mdash;</span>',
+            "choice_field": '<span class="text-secondary">&mdash;</span>',
+            "multi_choice_field": '<span class="text-secondary">&mdash;</span>',
+            "json_field": '<pre><code class="language-json">{}</code></pre>',
+            "markdown_field": '<span class="text-secondary">&mdash;</span>',
+        }
+
+        bound_row = location_table.rows[1]
+
+        for col_name, col_expected_value in custom_column_expected_2.items():
+            with self.subTest(col_name=col_name, col_expected_value=col_expected_value):
+                internal_col_name = "cf_" + col_name
+                custom_column = location_table.base_columns.get(internal_col_name)
+                self.assertIsNotNone(custom_column, internal_col_name)
+                self.assertIsInstance(custom_column, CustomFieldColumn)
 
-            rendered_value = bound_row.get_cell(internal_col_name)  # pylint: disable=no-member
-            self.assertEqual(rendered_value, col_expected_value)
+                rendered_value = bound_row.get_cell(internal_col_name)  # pylint: disable=no-member
+                self.assertHTMLEqual(str(rendered_value), str(col_expected_value))
 
 
 class CustomFieldFilterFormTest(TestCase):

nautobot/extras/tests/test_utils.py

@@ -2,22 +2,26 @@ from unittest import mock
 import uuid
 
 from django.core.cache import cache
+from django.test import override_settings
 
 from nautobot.core.testing import TestCase
 from nautobot.dcim.models import Cable, Device, PowerPort
 from nautobot.extras.choices import JobQueueTypeChoices
-from nautobot.extras.models import JobQueue
+from nautobot.extras.models import JobQueue, JobResult
 from nautobot.extras.registry import registry
 from nautobot.extras.utils import (
     get_base_template,
     get_celery_queues,
     get_worker_count,
     populate_model_features_registry,
+    run_kubernetes_job_and_return_job_result,
 )
 from nautobot.users.models import Token
 
 
 class UtilsTestCase(TestCase):
+    databases = ("default", "job_logs")
+
     def test_get_base_template(self):
         with self.subTest("explicitly specified base_template always wins"):
             self.assertEqual(get_base_template("dcim/device/base.html", Device), "dcim/device/base.html")
@@ -125,3 +129,114 @@ class UtilsTestCase(TestCase):
             original_custom_fields_registry,
             "Registry should be restored to original state",
         )
+
+    @override_settings(
+        KUBERNETES_JOB_POD_NAME="test-pod",
+        KUBERNETES_JOB_POD_NAMESPACE="test-namespace",
+        KUBERNETES_JOB_MANIFEST={
+            "metadata": {"name": "test-job"},
+            "spec": {
+                "template": {
+                    "spec": {
+                        "containers": [
+                            {
+                                "command": [],
+                            }
+                        ]
+                    }
+                }
+            },
+        },
+        KUBERNETES_SSL_CA_CERT_PATH="/path/to/ca.crt",
+        KUBERNETES_TOKEN_PATH="/path/to/token",  # noqa: S106
+        KUBERNETES_DEFAULT_SERVICE_ADDRESS="https://kubernetes.default.svc",
+    )
+    @mock.patch("nautobot.extras.utils.transaction.on_commit")
+    @mock.patch("builtins.open", new_callable=mock.mock_open, read_data="test-token\n")
+    @mock.patch("nautobot.extras.utils.kubernetes.client.BatchV1Api")
+    @mock.patch("nautobot.extras.utils.kubernetes.client.ApiClient")
+    @mock.patch("nautobot.extras.utils.kubernetes.client.Configuration")
+    def test_run_kubernetes_job_and_return_job_result(
+        self,
+        mock_configuration,
+        mock_api_client,
+        mock_batch_api,
+        mock_open,
+        mock_on_commit,
+    ):
+        """Test run_kubernetes_job_and_return_job_result function."""
+        # Setup test data
+        job_result = JobResult.objects.create(
+            name="Test Job",
+            user=self.user,
+        )
+        # Mock the log method to avoid database writes during test
+        job_result.log = mock.Mock()
+        job_kwargs = '{"key": "value"}'
+
+        # Setup kubernetes client mocks
+        mock_config_instance = mock.MagicMock()
+        mock_config_instance.api_key_prefix = {}
+        mock_config_instance.api_key = {}
+        mock_configuration.return_value = mock_config_instance
+
+        mock_api_client_instance = mock.Mock()
+        mock_api_client.return_value.__enter__.return_value = mock_api_client_instance
+        mock_api_client.return_value.__exit__.return_value = None
+
+        mock_api_instance = mock.Mock()
+        mock_batch_api.return_value = mock_api_instance
+
+        # Capture the callback passed to transaction.on_commit
+        commit_callback = None
+
+        def capture_callback(callback):
+            nonlocal commit_callback
+            commit_callback = callback
+            # Execute immediately for testing
+            callback()
+
+        mock_on_commit.side_effect = capture_callback
+
+        # Execute the function
+        result = run_kubernetes_job_and_return_job_result(job_result, job_kwargs)
+
+        # Verify job_result was updated and saved
+        job_result.refresh_from_db()
+        self.assertEqual(job_result.task_kwargs, job_kwargs)
+        self.assertEqual(result, job_result)
+
+        # Verify transaction.on_commit was called
+        mock_on_commit.assert_called_once()
+        self.assertIsNotNone(commit_callback)
+
+        # Verify kubernetes configuration was set up correctly
+        mock_configuration.assert_called_once()
+        self.assertEqual(mock_config_instance.host, "https://kubernetes.default.svc")
+        self.assertEqual(mock_config_instance.ssl_ca_cert, "/path/to/ca.crt")
+        self.assertEqual(mock_config_instance.api_key_prefix["authorization"], "Bearer")
+        self.assertEqual(mock_config_instance.api_key["authorization"], "test-token")
+
+        # Verify ApiClient was used as context manager
+        mock_api_client.assert_called_once_with(mock_config_instance)
+
+        # Verify BatchV1Api was created with the api_client_instance
+        mock_batch_api.assert_called_once_with(mock_api_client_instance)
+
+        # Verify the pod manifest was modified correctly
+        mock_api_instance.create_namespaced_job.assert_called_once()
+        create_call = mock_api_instance.create_namespaced_job.call_args
+        body = create_call[1]["body"]
+        self.assertEqual(body["metadata"]["name"], f"nautobot-job-{job_result.pk}")
+        self.assertEqual(
+            body["spec"]["template"]["spec"]["containers"][0]["command"],
+            ["nautobot-server", "runjob_with_job_result", str(job_result.pk)],
+        )
+        self.assertEqual(create_call[1]["namespace"], "test-namespace")
+
+        # Verify token file was opened
+        mock_open.assert_called_once_with("/path/to/token", "r", encoding="utf-8")
+
+        # Verify job_result.log was called (checking for log messages)
+        self.assertEqual(job_result.log.call_count, 1)
+        self.assertIn("Creating job pod", str(job_result.log.call_args_list[0]))

nautobot/extras/utils.py

@@ -668,7 +668,7 @@ def refresh_job_model_from_job_class(job_model_class, job_class, job_queue_class
     return (job_model, created)
 
 
-def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
+def run_kubernetes_job_and_return_job_result(job_result, job_kwargs):
     """
     Pass the job to a kubernetes pod and execute it there.
     """
@@ -678,17 +678,6 @@ def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
     pod_ssl_ca_cert = settings.KUBERNETES_SSL_CA_CERT_PATH
     pod_token = settings.KUBERNETES_TOKEN_PATH
 
-    configuration = kubernetes.client.Configuration()
-    configuration.host = settings.KUBERNETES_DEFAULT_SERVICE_ADDRESS
-    configuration.ssl_ca_cert = pod_ssl_ca_cert
-    with open(pod_token, "r") as token_file:
-        token = token_file.read().strip()
-    # configure API Key authorization: BearerToken
-    configuration.api_key_prefix["authorization"] = "Bearer"
-    configuration.api_key["authorization"] = token
-    with kubernetes.client.ApiClient(configuration) as api_client:
-        api_instance = kubernetes.client.BatchV1Api(api_client)
-
     job_result.task_kwargs = job_kwargs
     job_result.save()
     pod_manifest["metadata"]["name"] = "nautobot-job-" + str(job_result.pk)
@@ -697,10 +686,23 @@ def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
         "runjob_with_job_result",
         f"{job_result.pk}",
     ]
-    job_result.log(f"Creating job pod {pod_name} in namespace {pod_namespace}")
-    api_instance.create_namespaced_job(body=pod_manifest, namespace=pod_namespace)
-    job_result.log(f"Reading job pod {pod_name} in namespace {pod_namespace}")
-    api_instance.read_namespaced_job(name="nautobot-job-" + str(job_result.pk), namespace=pod_namespace)
+
+    def create_kubernetes_job():
+        """Create and read the Kubernetes job after the transaction commits."""
+        configuration = kubernetes.client.Configuration()
+        configuration.host = settings.KUBERNETES_DEFAULT_SERVICE_ADDRESS
+        configuration.ssl_ca_cert = pod_ssl_ca_cert
+        with open(pod_token, "r", encoding="utf-8") as token_file:
+            token = token_file.read().strip()
+        # configure API Key authorization: BearerToken
+        configuration.api_key_prefix["authorization"] = "Bearer"
+        configuration.api_key["authorization"] = token
+        with kubernetes.client.ApiClient(configuration) as api_client:
+            api_instance = kubernetes.client.BatchV1Api(api_client)
+            job_result.log(f"Creating job pod {pod_name} in namespace {pod_namespace}")
+            api_instance.create_namespaced_job(body=pod_manifest, namespace=pod_namespace)
+
+    transaction.on_commit(create_kubernetes_job)
     return job_result
 
 

nautobot/extras/views.py

@@ -820,7 +820,6 @@ class ComputedFieldUIViewSet(NautobotUIViewSet):
     serializer_class = serializers.ComputedFieldSerializer
     table_class = tables.ComputedFieldTable
     queryset = ComputedField.objects.all()
-    action_buttons = ("add",)
     object_detail_content = object_detail.ObjectDetailContent(
         panels=(
             object_detail.ObjectFieldsPanel(
@@ -1246,7 +1245,6 @@ class CustomFieldUIViewSet(NautobotUIViewSet):
     form_class = forms.CustomFieldForm
     table_class = tables.CustomFieldTable
     template_name = "extras/customfield_update.html"
-    action_buttons = ("add",)
 
     class CustomFieldObjectFieldsPanel(object_detail.ObjectFieldsPanel):
         def render_value(self, key, value, context):
@@ -1392,7 +1390,6 @@ class DynamicGroupUIViewSet(NautobotUIViewSet):
     queryset = DynamicGroup.objects.all()
     serializer_class = serializers.DynamicGroupSerializer
     table_class = tables.DynamicGroupTable
-    action_buttons = ("add",)
 
     def get_extra_context(self, request, instance):
         context = super().get_extra_context(request, instance)
@@ -1896,23 +1893,14 @@ class GitRepositoryUIViewSet(NautobotUIViewSet):
 #
 
 
-class GraphQLQueryUIViewSet(
-    ObjectDetailViewMixin,
-    ObjectListViewMixin,
-    ObjectEditViewMixin,
-    ObjectDestroyViewMixin,
-    ObjectBulkDestroyViewMixin,
-    ObjectChangeLogViewMixin,
-    ObjectDataComplianceViewMixin,
-    ObjectNotesViewMixin,
-):
+class GraphQLQueryUIViewSet(NautobotUIViewSet):
     filterset_form_class = forms.GraphQLQueryFilterForm
     queryset = GraphQLQuery.objects.all()
     form_class = forms.GraphQLQueryForm
     filterset_class = filters.GraphQLQueryFilterSet
     serializer_class = serializers.GraphQLQuerySerializer
     table_class = tables.GraphQLQueryTable
-    action_buttons = ("add",)
+    action_buttons = ("add", "export", "import")
 
     object_detail_content = object_detail.ObjectDetailContent(
         panels=(

nautobot/ipam/apps.py

@@ -9,6 +9,7 @@ class IPAMConfig(NautobotConfig):
         "ipaddress",
         "namespace",
         "prefix",
+        "service",
         "vlan",
         "vrf",
     ]

nautobot/ipam/filters.py

@@ -1,4 +1,5 @@
 import contextlib
+import ipaddress
 import uuid
 
 from django.core.exceptions import ValidationError
@@ -221,6 +222,10 @@ class PrefixFilterSet(
         method="filter_prefix",
         label="Prefix",
     )
+    prefix_exact = MultiValueCharFilter(
+        method="filter_prefix_exact",
+        label="Prefix (exact, strict)",
+    )
     within = MultiValueCharFilter(
         method="search_within",
         label="Within prefix",
@@ -327,6 +332,20 @@ class PrefixFilterSet(
             return queryset.net_equals(*prefixes)
         return queryset.none()
 
+    def filter_prefix_exact(self, queryset, name, value):
+        """
+        Strict version of `prefix` filter.
+        Rejects prefixes with host bits set (e.g. 10.32.0.34/28 vs 10.32.0.32/28).
+        """
+        prefixes = self._strip_values(value)
+
+        for prefix in prefixes:
+            try:
+                ipaddress.ip_network(prefix, strict=True)
+            except ValueError:
+                raise ValidationError(f"Invalid prefix_exact value as it is not a subnet boundary: {prefix}.")
+        return self.filter_prefix(queryset, name, value)
+
     def search_within(self, queryset, name, value):
         prefixes = self._strip_values(value)
         with contextlib.suppress(netaddr.AddrFormatError, ValueError):
@@ -417,6 +436,10 @@ class IPAddressFilterSet(
         method="search_by_prefix",
         label="Contained in prefix",
     )
+    prefix_exact = MultiValueCharFilter(
+        method="search_by_prefix_exact",
+        label="Prefix (exact, strict)",
+    )
     address = MultiValueCharFilter(
         method="filter_address",
         label="Address",
@@ -512,17 +535,49 @@ class IPAddressFilterSet(
         params = self.generate_query__has_interface_assignments(value)
         return queryset.filter(params)
 
-    def search_by_prefix(self, queryset, name, value):
+    def _strip_prefix_values(self, values):
+        """Normalize inputs: strip whitespace + resolve UUIDs to Prefix.prefix."""
         prefixes = []
-        for prefix in value:
+        for prefix in values:
             prefix = prefix.strip()
+            if not prefix:
+                continue
             if is_uuid(prefix):
                 prefixes.append(Prefix.objects.get(pk=prefix).prefix)
-            elif prefix:
+            else:
                 prefixes.append(prefix)
+        return prefixes
 
+    def search_by_prefix(self, queryset, name, value):
+        prefixes = self._strip_prefix_values(value)
         return queryset.net_host_contained(*prefixes)
 
+    def search_by_prefix_exact(self, queryset, name, value):
+        """
+        Strict version of `prefix` filter.
+        Rejects prefixes with host bits set (e.g. 10.32.0.34/28 vs 10.32.0.32/28).
+        """
+        prefixes = self._strip_prefix_values(value)
+
+        # Validate network is on CIDR boundary
+        for prefix in prefixes:
+            if "/" not in str(prefix):
+                # If someone passes a host-only string here, treat it as invalid for "prefix_exact".
+                raise ValidationError(f"Invalid prefix_exact value (missing mask): {prefix}")
+
+            with contextlib.suppress(netaddr.AddrFormatError, ValueError):
+                ip_network = netaddr.IPNetwork(str(prefix)).cidr
+                # cidr will always a proper network subnet; compare against original input
+                if str(ip_network) != str(prefix):
+                    raise ValidationError(
+                        f"Invalid prefix_exact value as it is not a subnet boundary: {prefix}, did you mean {ip_network}?"
+                    )
+                continue
+
+            # Defensive programming in case there is logic missed above
+            raise ValidationError(f"Invalid prefix_exact value as it is not a subnet boundary: {prefix}.")
+        return self.search_by_prefix(queryset, name, prefixes)
+
     def filter_address(self, queryset, name, value):
         try:
             return queryset.net_in(value)

nautobot/ipam/tables.py

@@ -40,7 +40,11 @@ AVAILABLE_LABEL = mark_safe('<span class="badge bg-success">Available</span>')
 
 UTILIZATION_GRAPH = """
 {% load helpers %}
-{% if record.present_in_database %}{% utilization_graph record.get_utilization %}{% else %}&mdash;{% endif %}
+{% if record.present_in_database %}
+    {% utilization_graph record.get_utilization %}
+{% else %}
+    <span class="text-secondary">&mdash;</span>
+{% endif %}
 """
 
 
@@ -73,7 +77,7 @@ PREFIX_ROLE_LINK = """
 {% if record.role %}
     <a href="{% url 'ipam:prefix_list' %}?role={{ record.role.name }}">{{ record.role }}</a>
 {% else %}
-    &mdash;
+    <span class="text-secondary">&mdash;</span>
 {% endif %}
 """
 
@@ -157,7 +161,7 @@ VRF_TARGETS = """
 {% for rt in value.all %}
     <a href="{{ rt.get_absolute_url }}">{{ rt }}</a>{% if not forloop.last %}<br />{% endif %}
 {% empty %}
-    &mdash;
+    <span class="text-secondary">&mdash;</span>
 {% endfor %}
 """
 
@@ -179,7 +183,7 @@ VLAN_PREFIXES = """
 {% for prefix in record.prefixes.all %}
     <a href="{% url 'ipam:prefix' pk=prefix.pk %}">{{ prefix }}</a>{% if not forloop.last %}<br />{% endif %}
 {% empty %}
-    &mdash;
+    <span class="text-secondary">&mdash;</span>
 {% endfor %}
 """
 

nautobot/ipam/tests/test_filters.py

@@ -1,4 +1,5 @@
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
 from django.db.models import Q
 
 from nautobot.core.testing import FilterTestCases, TestCase
@@ -242,6 +243,32 @@ class PrefixTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilt
         ancestors = [ancestor.id for ancestor in prefixes[2].ancestors()]
         self.assertQuerysetEqualAndNotEmpty(filterset.qs, self.queryset.filter(id__in=ancestors))
 
+    def test_prefix(self):
+        Prefix.objects.create(
+            prefix="192.0.2.0/29",
+            type=PrefixTypeChoices.TYPE_POOL,
+            namespace=Namespace.objects.first(),
+            status=Status.objects.get_for_model(Prefix).first(),
+        )
+        params = {"prefix": "192.0.2.0/29"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"prefix": "192.0.2.1/29"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+
+    def test_prefix_exact(self):
+        Prefix.objects.create(
+            prefix="192.0.2.0/29",
+            type=PrefixTypeChoices.TYPE_POOL,
+            namespace=Namespace.objects.first(),
+            status=Status.objects.get_for_model(Prefix).first(),
+        )
+        params = {"prefix_exact": "192.0.2.0/29"}
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
+        params = {"prefix_exact": "192.0.2.1/29"}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value" in str(exc.exception))
+
 
 class PrefixLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
     queryset = PrefixLocationAssignment.objects.all()
@@ -807,6 +834,34 @@ class IPAddressTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyF
             self.filterset(params, self.queryset).qs, self.queryset.net_host_contained(ipv4_parent, ipv6_parent)
         )
 
+    def test_prefix_exact(self):
+        ipv4_parent = self.queryset.filter(ip_version=4).first().address.supernet()[-1]
+        ipv6_parent = self.queryset.filter(ip_version=6).first().address.supernet()[-1]
+
+        params = {"prefix_exact": [str(ipv4_parent), str(ipv6_parent)]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.net_host_contained(ipv4_parent, ipv6_parent)
+        )
+
+        # Get the first usable IP address in the subnet (not the network address)
+        ipv4_parent = self.queryset.filter(ip_version=4).first().address
+        ipv6_parent = self.queryset.filter(ip_version=6).first().address
+
+        params = {"prefix_exact": [str(ipv4_parent)]}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value" in str(exc.exception))
+
+        params = {"prefix_exact": [str(ipv6_parent)]}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value" in str(exc.exception))
+
+        params = {"prefix_exact": ["10.1.1.1"]}
+        with self.assertRaises(ValidationError) as exc:
+            self.filterset(params, self.queryset).qs  # pylint: disable=expression-not-assigned
+        self.assertTrue("Invalid prefix_exact value (missing mask)" in str(exc.exception))
+
     def test_filter_address(self):
         """Check IPv4 and IPv6, with and without a mask"""
         ipv4_addresses = self.queryset.filter(ip_version=4)[:2]