nautobot 2.3.2__py3-none-any.whl → 2.3.4__py3-none-any.whl

nautobot/core/celery/schedulers.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from datetime import datetime
+from datetime import datetime, timedelta
 import logging
 from pathlib import Path
 
@@ -83,7 +83,7 @@ class NautobotScheduleEntry(ModelEntry):
             # This will trigger the job to run at start_time
             # and avoid the heap block.
             if model.start_time:
-                model.last_run_at = model.last_run_at - datetime.timedelta(days=365 * 30)
+                model.last_run_at = model.last_run_at - timedelta(days=365 * 30)
 
         self.last_run_at = model.last_run_at
 

nautobot/core/settings.py

@@ -641,6 +641,8 @@ LOGIN_REDIRECT_URL = "home"
 CONSTANCE_BACKEND = "constance.backends.database.DatabaseBackend"
 CONSTANCE_DATABASE_PREFIX = "constance:nautobot:"
 CONSTANCE_DATABASE_CACHE_BACKEND = "default"
+# Constance defaults to a 24-hour timeout when autofilling its cache, which is undesirable in many cases.
+CONSTANCE_DATABASE_CACHE_AUTOFILL_TIMEOUT = int(os.getenv("NAUTOBOT_CACHES_TIMEOUT", "300"))
 CONSTANCE_IGNORE_ADMIN_VERSION_CHECK = True  # avoid potential errors in a multi-node deployment
 
 CONSTANCE_ADDITIONAL_FIELDS = {
@@ -853,7 +855,7 @@ CACHES = {
             "django_prometheus.cache.backends.redis.RedisCache" if METRICS_ENABLED else "django_redis.cache.RedisCache",
         ),
         "LOCATION": parse_redis_connection(redis_database=1),
-        "TIMEOUT": 300,
+        "TIMEOUT": int(os.getenv("NAUTOBOT_CACHES_TIMEOUT", "300")),
         "OPTIONS": {
             "CLIENT_CLASS": "django_redis.client.DefaultClient",
             "PASSWORD": "",

nautobot/core/settings.yaml

@@ -47,7 +47,7 @@ properties:
     description: >-
       A list of valid fully-qualified domain names (FQDNs) and/or IP addresses that can be used to reach the
       Nautobot service. (If provided as an environment variable, it should be a space-separated string, for example
-      `NAUTOBOT_ALLOWED_HOSTS="localhost 127.0.0.1 example.com"`)
+      `NAUTOBOT_ALLOWED_HOSTS="localhost 127.0.0.1 nautobot.example.com"`)
     details: |-
       Usually this is the same as the hostname for the Nautobot server, but can also be different; for example,
       when using a reverse proxy serving the Nautobot website under a different FQDN than the hostname of the
@@ -70,7 +70,7 @@ properties:
 
       !!! tip
           If there is more than one hostname in this list, you may also need to set
-          [CSRF_TRUSTED_ORIGINS](optional-settings.md#csrf_trusted_origins) as well.
+          [CSRF_TRUSTED_ORIGINS](settings.md#csrf_trusted_origins) as well.
 
       If you are not yet sure what the domain name and/or IP address of the Nautobot installation will be,
       and are comfortable accepting the risks in doing so, you can set this to a wildcard (asterisk) to
@@ -83,7 +83,6 @@ properties:
       !!! warning
           It is not recommended to leave this value as `['*']` for production deployments.
     environment_variable: "NAUTOBOT_ALLOWED_HOSTS"
-    is_required_setting: true
     items:
       type: "string"
     see_also:
@@ -297,19 +296,21 @@ properties:
         TIMEOUT: 300
     description: "The `CACHES` setting is required to simplify the configuration for `django-redis`."
     details: |-
-      The [`django-redis`](https://github.com/jazzband/django-redis) Django plugin is used to enable Redis
-      as a concurrent write lock for preventing race conditions when allocating IP address objects.
+      The [`django-redis`](https://github.com/jazzband/django-redis) Django plugin is used to enable Redis as a
+      concurrent write lock for preventing race conditions when allocating IP address objects.
+      Nautobot also uses the built-in [Django cache framework](https://docs.djangoproject.com/en/stable/topics/cache/)
+      (which also relies on the `CACHES` setting) to perform caching. This includes caching of the values of
+      [administratively configurable settings](#administratively-configurable-settings) as stored in the database.
 
-      !!! important
-          Nautobot also utilizes the built-in
-          [Django cache framework](https://docs.djangoproject.com/en/stable/topics/cache/)
-          (which also relies on the `CACHES` setting) to perform caching.
-
-      +/- 2.0.0
-          The default value of `CACHES["default"]["LOCATION"]` has changed from `redis://localhost:6379/0`
-          to `redis://localhost:6379/1`, as Django's native caching is now taking the role previously occupied by
-          `django-cacheops`.
-    is_required_setting: true
+      !!! tip
+          Rather than directly setting `CACHES["default"]["LOCATION"]`, we recommend managing this setting via
+          the various `NAUTOBOT_REDIS_*` environment variables, as those variables apply to both `CACHES` and
+          [`CELERY_BROKER_URL`](#celery_broker_url) alike, which is typically preferable.
+
+      +++ 2.3.4 "`NAUTOBOT_CACHES_TIMEOUT` environment variable"
+          Added support for the environment variable `NAUTOBOT_CACHES_TIMEOUT` for configuring the
+          `CACHES["default"]["TIMEOUT"]` setting. This environment variable also controls the cache timeout
+          for administratively configurable settings.
     properties:
       default:
         properties:
@@ -322,6 +323,13 @@ properties:
             type: "string"
           LOCATION:
             default: "redis://localhost:6379/1"
+            environment_variables:
+            - "NAUTOBOT_REDIS_SCHEME"
+            - "NAUTOBOT_REDIS_SSL"
+            - "NAUTOBOT_REDIS_USERNAME"
+            - "NAUTOBOT_REDIS_PASSWORD"
+            - "NAUTOBOT_REDIS_HOST"
+            - "NAUTOBOT_REDIS_PORT"
             format: "uri"
             type: "string"
           OPTIONS:
@@ -336,10 +344,11 @@ properties:
             type: "object"
           TIMEOUT:
             default: 300
+            environment_variable: "NAUTOBOT_CACHES_TIMEOUT"
             type: "integer"
         type: "object"
     see_also:
-      "Guide to Nautobot Caching, including TLS and HA configuration": "../../administration/guides/caching.md"
+      "Guide to Nautobot Redis configuration, including TLS and HA configuration": "redis.md"
     type: "object"
   CELERY_BEAT_HEARTBEAT_FILE:
     default: "/tmp/nautobot_celery_beat_heartbeat"
@@ -351,8 +360,7 @@ properties:
     default: {}
     description: "A dict of additional options passed to the Celery broker transport."
     details: >-
-      This is only required when
-      [configuring Celery to utilize Redis Sentinel](../../administration/guides/caching.md#celery-sentinel-configuration).
+      This is only required when [configuring Celery to utilize Redis Sentinel](redis.md#celery-sentinel-configuration).
     properties:
       master_name:
         type: "string"
@@ -366,7 +374,18 @@ properties:
   CELERY_BROKER_URL:
     default: "redis://localhost:6379/0"
     description: "Celery broker URL used to tell workers where queues are located."
-    environment_variable: "NAUTOBOT_CELERY_BROKER_URL"
+    details: >-
+      If the `NAUTOBOT_CELERY_BROKER_URL` environment variable is not set, the default for this setting will be
+      influenced by the various `NAUTOBOT_REDIS_*` environment variables instead, which is often preferable as those
+      variables also influence the [`CACHES`](#caches) configuration as well.
+    environment_variables:
+    - "NAUTOBOT_CELERY_BROKER_URL"
+    - "NAUTOBOT_REDIS_SCHEME"
+    - "NAUTOBOT_REDIS_SSL"
+    - "NAUTOBOT_REDIS_USERNAME"
+    - "NAUTOBOT_REDIS_PASSWORD"
+    - "NAUTOBOT_REDIS_HOST"
+    - "NAUTOBOT_REDIS_PORT"
     format: "uri"
     type: "string"
   CELERY_BROKER_USE_SSL:
@@ -628,7 +647,6 @@ properties:
 
           As of Nautobot 1.1.5 and later, if you have generated a new `nautobot_config.py` using
           `nautobot-server init`, this line is already present in your config and no action is required.
-    is_required_setting: true
     properties:
       default:
         additionalProperties: true
@@ -828,7 +846,7 @@ properties:
   FORCE_SCRIPT_NAME:
     default: null
     description: >-
-      If not None, this will be used as the value of the SCRIPT_NAME environment variable in any HTTP request.
+      If not None, this will be used as the value of the `SCRIPT_NAME` environment variable in any HTTP request.
     details: |-
       This setting can be used to override the server-provided value of `SCRIPT_NAME`, which is most commonly used
       for hosting Nautobot in a subdirectory (e.g. _example.com/nautobot/_).
@@ -1205,7 +1223,7 @@ properties:
       !!! note
           The Docker container normally attempts to run migrations on startup; however, if the database is
           in a read-only state the Docker container will fail to start. Setting the environment variable
-          [`NAUTOBOT_DOCKER_SKIP_INIT`](../installation-extras/docker.md#nautobot_docker_skip_init) to `true`
+          [`NAUTOBOT_DOCKER_SKIP_INIT`](../guides/docker.md#nautobot_docker_skip_init) to `true`
           will prevent the migrations from occurring.
 
       !!! note
@@ -1609,7 +1627,6 @@ properties:
           In the case of a highly available installation with multiple web servers, `SECRET_KEY` must be identical
           among all servers in order to maintain a persistent user session state.
     environment_variable: "NAUTOBOT_SECRET_KEY"
-    is_required_setting: true
     type: "string"
   SESSION_CACHE_ALIAS:
     default: "default"

nautobot/core/tests/runner.py

@@ -1,6 +1,13 @@
 import copy
 import hashlib
 
+try:
+    from coverage import Coverage
+
+    has_coverage = True
+except ImportError:
+    has_coverage = False
+
 from django.conf import settings
 from django.core.management import call_command
 from django.db import connections
@@ -49,6 +56,15 @@ class NautobotTestRunner(DiscoverRunner):
 
     exclude_tags = ["integration"]
 
+    @classmethod
+    def add_arguments(cls, parser):
+        super().add_arguments(parser)
+        parser.add_argument(
+            "--cache-test-fixtures",
+            action="store_true",
+            help="Save test database to a json fixture file to re-use on subsequent tests.",
+        )
+
     def __init__(self, cache_test_fixtures=False, **kwargs):
         self.cache_test_fixtures = cache_test_fixtures
 
@@ -64,15 +80,6 @@ class NautobotTestRunner(DiscoverRunner):
 
         super().__init__(**kwargs)
 
-    @classmethod
-    def add_arguments(cls, parser):
-        super().add_arguments(parser)
-        parser.add_argument(
-            "--cache-test-fixtures",
-            action="store_true",
-            help="Save test database to a json fixture file to re-use on subsequent tests.",
-        )
-
     def setup_test_environment(self, **kwargs):
         super().setup_test_environment(**kwargs)
         # Remove 'testserver' that Django "helpfully" adds automatically to ALLOWED_HOSTS, masking issues like #3065
@@ -91,6 +98,13 @@ class NautobotTestRunner(DiscoverRunner):
 
         old_names = []
 
+        # Nautobot specific - disable coverage measurement to improve performance of (slow) database setup
+        cov = None
+        if has_coverage:
+            cov = Coverage.current()
+        if cov is not None:
+            cov.stop()
+
         for db_name, aliases in test_databases.values():
             first_alias = None
             for alias in aliases:
@@ -150,6 +164,10 @@ class NautobotTestRunner(DiscoverRunner):
             for alias in connections:
                 connections[alias].force_debug_cursor = True
 
+        # Nautobot specific - resume test coverage measurement
+        if cov is not None:
+            cov.start()
+
         return old_names
 
     def teardown_databases(self, old_config, **kwargs):

nautobot/core/tests/test_settings_schema.py

@@ -35,10 +35,13 @@ SETTINGS_DOCUMENTATION_SCHEMA = {
         "environment_variable": {
             "type": "string",
         },
-        "is_constance_config": {
-            "type": "boolean",
+        "environment_variables": {
+            "type": "array",
+            "items": {
+                "type": "string",
+            },
         },
-        "is_required_setting": {
+        "is_constance_config": {
             "type": "boolean",
         },
         "see_also": {
@@ -122,6 +125,7 @@ class SettingsJSONSchemaTestCase(TestCase):
             "CONSTANCE_BACKEND",
             "CONSTANCE_CONFIG",
             "CONSTANCE_CONFIG_FIELDSETS",
+            "CONSTANCE_DATABASE_CACHE_AUTOFILL_TIMEOUT",
             "CONSTANCE_DATABASE_CACHE_BACKEND",
             "CONSTANCE_DATABASE_PREFIX",
             "CSRF_FAILURE_VIEW",

nautobot/core/tests/test_utils.py

@@ -234,6 +234,19 @@ class GetFooForModelTest(TestCase):
         self.assertEqual(lookup.get_model_from_name("dcim.device"), dcim_models.Device)
         self.assertEqual(lookup.get_model_from_name("dcim.location"), dcim_models.Location)
 
+    def test_get_model_for_view_name(self):
+        """
+        Test the util function `get_model_for_view_name` returns the appropriate Model, if the colon separated view name provided.
+        """
+        with self.subTest("Test core view."):
+            self.assertEqual(lookup.get_model_for_view_name("dcim:device_list"), dcim_models.Device)
+        with self.subTest("Test app view."):
+            self.assertEqual(lookup.get_model_for_view_name("plugins:example_app:examplemodel_list"), ExampleModel)
+        with self.subTest("Test unexpected view."):
+            with self.assertRaises(ValueError) as err:
+                lookup.get_model_for_view_name("unknown:plugins:example_app:examplemodel_list")
+            self.assertEqual(str(err.exception), "Unexpected View Name: unknown:plugins:example_app:examplemodel_list")
+
 
 class IsTaggableTest(TestCase):
     def test_is_taggable_true(self):

nautobot/core/utils/lookup.py

@@ -213,7 +213,13 @@ def get_model_for_view_name(view_name):
     Return the model class associated with the given view_name e.g. "circuits:circuit_detail", "dcim:device_list" and etc.
     If the app_label or model_name contained by the given view_name is invalid, this will return `None`.
     """
-    app_label, model_name = view_name.split(":")  # dcim, device_list
+    split_view_name = view_name.split(":")
+    if len(split_view_name) == 2:
+        app_label, model_name = split_view_name  # dcim, device_list
+    elif len(split_view_name) == 3:
+        _, app_label, model_name = split_view_name  # plugins, app_name, model_list
+    else:
+        raise ValueError(f"Unexpected View Name: {view_name}")
     model_name = model_name.split("_")[0]  # device
 
     try:

nautobot/dcim/tables/power.py

@@ -29,7 +29,7 @@ class PowerPanelTable(BaseTable):
     location = tables.Column(linkify=True)
     power_feed_count = LinkedCountColumn(
         viewname="dcim:powerfeed_list",
-        url_params={"power_panel_id": "pk"},
+        url_params={"power_panel": "pk"},
         verbose_name="Feeds",
     )
     tags = TagColumn(url_name="dcim:powerpanel_list")

nautobot/dcim/tests/test_filters.py

@@ -3349,7 +3349,7 @@ class CableTestCase(FilterTestCases.FilterTestCase):
 
     def test_device(self):
         """Test that the device filter returns all cables for a device and its modules."""
-        interfaces = Interface.objects.filter(cable__isnull=True)[:3]
+        interfaces = list(Interface.objects.filter(cable__isnull=True)[:3])
         manufacturer = Manufacturer.objects.first()
         device_type = DeviceType.objects.create(
             manufacturer=manufacturer, model="Test Device Filter for Cable Device Type"

nautobot/extras/context_managers.py

@@ -175,11 +175,12 @@ def web_request_context(
     :param user: User object
     :param context_detail: Optional extra details about the transaction (ex: the plugin name that initiated the change)
     :param change_id: Optional uuid object to uniquely identify the transaction. One will be generated if not supplied
-    :param context: Optional string value of the generated change log entries' "change_context" field, defaults to ObjectChangeEventContextChoices.CONTEXT_ORM.
-        Valid choices are in nautobot.extras.choices.ObjectChangeEventContextChoices
+    :param context: Optional string value of the generated change log entries' "change_context" field.
+        Defaults to `ObjectChangeEventContextChoices.CONTEXT_ORM`.
+        Valid choices are in `nautobot.extras.choices.ObjectChangeEventContextChoices`.
     :param request: Optional web request instance, one will be generated if not supplied
     """
-    from nautobot.extras.jobs import enqueue_job_hooks  # prevent circular import
+    from nautobot.extras.jobs import enqueue_job_hooks, get_jobs  # prevent circular import
 
     valid_contexts = {
         ObjectChangeEventContextChoices.CONTEXT_JOB: JobChangeContext,
@@ -202,9 +203,15 @@ def web_request_context(
         with change_logging(change_context):
             yield request
     finally:
+        jobs_refreshed = False
         # enqueue jobhooks and webhooks, use change_context.change_id in case change_id was not supplied
         for object_change in ObjectChange.objects.filter(request_id=change_context.change_id).iterator():
-            enqueue_job_hooks(object_change)
+            if context != ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK:
+                # Make sure JobHooks are up to date (once) before calling them
+                if not jobs_refreshed:
+                    get_jobs(reload=True)
+                    jobs_refreshed = True
+                enqueue_job_hooks(object_change)
             enqueue_webhooks(object_change)
 
 

nautobot/extras/jobs.py

@@ -1168,7 +1168,6 @@ def enqueue_job_hooks(object_change):
     job_hooks = JobHook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
 
     # Enqueue the jobs related to the job_hooks
-    get_jobs(reload=True)
     for job_hook in job_hooks:
         job_model = job_hook.job
         if not job_model.installed or not job_model.enabled:

nautobot/extras/models/groups.py

@@ -251,7 +251,10 @@ class DynamicGroup(PrimaryModel):
             # Skip filter fields that have methods defined. They are not reversible.
             if skip_method_filters and filterset_field.method is not None:
                 # Don't skip method fields that also have a "generate_query_" method
-                if hasattr(filterset, "generate_query_" + filterset_field.method):
+                query_attr = (
+                    filterset_field.method.__name__ if callable(filterset_field.method) else filterset_field.method
+                )
+                if hasattr(filterset, f"generate_query_{query_attr}"):
                     logger.debug(
                         "Keeping %s for filterform: has a `generate_query_` filter method", filterset_field_name
                     )

nautobot/extras/tests/test_context_managers.py

@@ -1,3 +1,5 @@
+from unittest import mock
+
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.test import TestCase
@@ -72,7 +74,9 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(oc_list[0].changed_object, location)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
 
-    def test_create_then_delete(self):
+    @mock.patch("nautobot.extras.jobs.enqueue_job_hooks")
+    @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
+    def test_create_then_delete(self, mock_enqueue_webhooks, mock_enqueue_job_hooks):
         """Test that a create followed by a delete is logged as two changes"""
         location_type = LocationType.objects.get(name="Campus")
         location_status = Status.objects.get_for_model(Location).first()
@@ -88,6 +92,8 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(len(oc_list), 2)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_DELETE)
         self.assertEqual(oc_list[1].action, ObjectChangeActionChoices.ACTION_CREATE)
+        mock_enqueue_job_hooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
+        mock_enqueue_webhooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
 
     def test_update_then_delete(self):
         """Test that an update followed by a delete is logged as a single delete"""
@@ -179,21 +185,30 @@ class WebRequestContextTestCase(TestCase):
         with self.subTest():
             self.assertEqual(oc_list[0].change_context_detail, "test_change_log_context")
 
-    def test_change_webhook_enqueued(self):
+    @mock.patch("nautobot.extras.webhooks.process_webhook.apply_async")
+    def test_change_webhook_enqueued(self, mock_apply_async):
         """Test that the webhook resides on the queue"""
-        # TODO(john): come back to this with a way to actually do it without a running worker
-        # The celery inspection API expects to be able to communicate with at least 1 running
-        # worker and there does not appear to be an easy way to look into the queues directly.
-        # with web_request_context(self.user):
-        #    site = Site(name="Test Site 2")
-        #    site.save()
+        with web_request_context(self.user):
+            location = Location(
+                name="Test Location 2",
+                location_type=LocationType.objects.get(name="Campus"),
+                status=Status.objects.get_for_model(Location).first(),
+            )
+            location.save()
 
         # Verify that a job was queued for the object creation webhook
-        # site = Site.objects.get(name="Test Site 2")
-
-        # self.assertEqual(job.args[0], Webhook.objects.get(type_create=True))
-        # self.assertEqual(job.args[1]["id"], str(site.pk))
-        # self.assertEqual(job.args[2], "site")
+        oc_list = get_changes_for_model(location)
+        mock_apply_async.assert_called_once()
+        call_args = mock_apply_async.call_args.kwargs["args"]
+        self.assertEqual(8, len(call_args), call_args)
+        self.assertEqual(call_args[0], Webhook.objects.get(type_create=True).pk)
+        self.assertEqual(call_args[1], oc_list[0].object_data_v2)
+        self.assertEqual(call_args[2], "location")
+        self.assertEqual(call_args[3], "create")
+        self.assertIsInstance(call_args[4], str)  # str(timezone.now())
+        self.assertEqual(call_args[5], self.user.username)
+        self.assertEqual(call_args[6], oc_list[0].request_id)
+        self.assertEqual(call_args[7], oc_list[0].get_snapshots())
 
 
 class WebRequestContextTransactionTestCase(TransactionTestCase):
@@ -282,7 +297,8 @@ class BulkEditDeleteChangeLogging(TestCase):
         self.assertIsNone(snapshots["differences"]["removed"])
         self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
 
-    def test_bulk_edit(self):
+    @mock.patch("nautobot.extras.jobs.import_jobs")
+    def test_bulk_edit(self, mock_import_jobs):
         """Test that edits to multiple objects are correctly logged"""
         location_type = LocationType.objects.get(name="Campus")
         location_status = Status.objects.get_for_model(Location).first()
@@ -309,6 +325,9 @@ class BulkEditDeleteChangeLogging(TestCase):
             self.assertIsNone(snapshots["differences"]["removed"])
             self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
 
+        # Check for regression of https://github.com/nautobot/nautobot/issues/6203
+        mock_import_jobs.assert_called_once()
+
     def test_bulk_edit_device_type_software_image_file(self):
         """Test that bulk edits to null does not cause integrity error"""
         manufacturer = Manufacturer.objects.create(name="Test")

nautobot/extras/tests/test_dynamicgroups.py

@@ -494,6 +494,17 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         self.assertIsInstance(fields["cluster"], MultiMatchModelMultipleChoiceField)
         self.assertIsInstance(fields["cluster"].widget, APISelectMultiple)
 
+    def test_map_filter_fields_with_custom_filter_method(self):
+        """
+        Test that extension_filters with custom methods can be concatenated into `generate_query_{filter_method}`
+        and _map_filter_fields method doesn't brake on string concatenation.
+        This is a regression test for issue #6184.
+        """
+        tenant_content_type = ContentType.objects.get_for_model(Tenant)
+        # using Tenant as example app has a custom filter with a custom method.
+        group = DynamicGroup(name="tenant", content_type=tenant_content_type)
+        self.assertIsInstance(group._map_filter_fields, dict)
+
     def test_map_filter_fields_skip_missing(self):
         """
         Test that missing fields are skipped in `DynamicGroup._map_filter_fields`

nautobot/extras/tests/test_models.py

@@ -1091,12 +1091,15 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
     def test_job_class(self):
+        self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.job_class.description, "Validate job import")
 
+        self.assertIsNotNone(self.app_job.job_class)
         self.assertEqual(self.app_job.job_class, ExampleJob)
 
     def test_class_path(self):
         self.assertEqual(self.local_job.class_path, "pass.TestPass")
+        self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.class_path, self.local_job.job_class.class_path)
 
         self.assertEqual(self.app_job.class_path, "example_app.jobs.ExampleJob")
@@ -1118,6 +1121,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
                         self.assertTrue(job_model.enabled)
                     else:
                         self.assertFalse(job_model.enabled)
+                    self.assertIsNotNone(job_model.job_class)
                     for field_name in JOB_OVERRIDABLE_FIELDS:
                         if field_name == "name" and "duplicate_name" in job_model.job_class.__module__:
                             pass  # name field for test_duplicate_name jobs tested in test_duplicate_job_name below
@@ -1173,6 +1177,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
             setattr(self.job_containing_sensitive_variables, f"{field_name}_override", False)
         self.job_containing_sensitive_variables.validated_save()
         self.job_containing_sensitive_variables.refresh_from_db()
+        self.assertIsNotNone(self.job_containing_sensitive_variables.job_class)
         for field_name in overridden_attrs:
             self.assertEqual(
                 getattr(self.job_containing_sensitive_variables, field_name),

nautobot/extras/tests/test_views.py

@@ -3008,6 +3008,7 @@ class JobCustomTemplateTestCase(TestCase):
         cls.run_url = reverse("extras:job_run", kwargs={"pk": cls.example_job.pk})
 
     def test_rendering_custom_template(self):
+        self.assertIsNotNone(self.example_job.job_class)
         obj_perm = ObjectPermission(name="Test permission", actions=["view", "run"])
         obj_perm.save()
         obj_perm.users.add(self.user)

nautobot/ipam/models.py

@@ -535,6 +535,10 @@ class Prefix(PrimaryModel):
     def __str__(self):
         return str(self.prefix)
 
+    @property
+    def display(self):
+        return f"{self.prefix}: {self.namespace}"
+
     def _deconstruct_prefix(self, prefix):
         if prefix:
             if isinstance(prefix, str):

nautobot/ipam/tests/test_api.py

@@ -443,6 +443,17 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         for i, p in enumerate(response.data):
             self.assertEqual(p["prefix"], str(available_prefixes[i]))
 
+    def test_prefix_display_value(self):
+        """
+        Test that the `display` field is correctly populated.
+        """
+        url = reverse("ipam-api:prefix-list")
+        self.add_permissions("ipam.view_prefix")
+
+        response = self.client.get(f"{url}?depth=1", **self.header)
+        for p in response.data["results"]:
+            self.assertEqual(p["display"], f'{p["prefix"]}: {p["namespace"]["name"]}')
+
     def test_create_single_available_prefix(self):
         """
         Test retrieval of the first available prefix within a parent prefix.