nautobot 2.4.20__py3-none-any.whl → 2.4.21__py3-none-any.whl

nautobot/circuits/templates/circuits/circuit.html

@@ -1,2 +1,2 @@
-{% extends 'circuits/circuit_retrieve.html' %}
+{% extends 'generic/object_retrieve.html' %}
 {% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}

nautobot/circuits/templates/circuits/circuittermination.html

@@ -1,2 +1,2 @@
-{% extends 'circuits/circuittermination_retrieve.html' %}
+{% extends 'generic/object_retrieve.html' %}
 {% comment %}2.0 TODO: remove this template, which only exists for backward compatibility with 1.3 and earlier{% endcomment %}

nautobot/circuits/templates/circuits/circuittype.html

@@ -1,2 +1,2 @@
-{% extends 'circuits/circuittype_retrieve.html' %}
+{% extends 'generic/object_retrieve.html' %}
 {% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/circuits/templates/circuits/providernetwork.html

@@ -1,2 +1,2 @@
-{% extends 'circuits/providernetwork_retrieve.html' %}
+{% extends 'generic/object_retrieve.html' %}
 {% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/core/cli/migrate_deprecated_templates.py

@@ -0,0 +1,200 @@
+import argparse
+import os
+import re
+
+TEMPLATE_REPLACEMENTS = {
+    # Format: new_template: [old_template1, old_template2, ...]
+    "circuits/circuit_create.html": ["circuits/circuit_edit.html"],
+    "circuits/circuittermination_create.html": ["circuits/circuittermination_edit.html"],
+    "circuits/provider_create.html": ["circuits/provider_edit.html"],
+    "circuits/provider_retrieve.html": ["circuits/provider.html"],
+    "dcim/cable_retrieve.html": ["dcim/cable.html"],
+    "dcim/cable_update.html": ["dcim/cable_edit.html"],
+    "dcim/device_create.html": ["dcim/device_edit.html"],
+    "dcim/devicetype_update.html": ["dcim/devicetype_edit.html"],
+    "dcim/location_retrieve.html": ["dcim/location.html"],
+    "dcim/location_update.html": ["dcim/location_edit.html"],
+    "dcim/rack_retrieve.html": ["dcim/rack.html"],
+    "dcim/rack_update.html": ["dcim/rack_edit.html"],
+    "dcim/rackreservation_retrieve.html": ["dcim/rackreservation.html"],
+    "dcim/virtualchassis_create.html": ["dcim/virtualchassis_add.html"],
+    "extras/configcontext_update.html": ["extras/configcontext_edit.html"],
+    "extras/configcontextschema_retrieve.html": ["extras/configcontextschema.html"],
+    "extras/configcontextschema_update.html": ["extras/configcontextschema_edit.html"],
+    "extras/customfield_update.html": ["extras/customfield_edit.html"],
+    "extras/dynamicgroup_retrieve.html": ["extras/dynamicgroup.html"],
+    "extras/dynamicgroup_update.html": ["extras/dynamicgroup_edit.html"],
+    "extras/gitrepository_retrieve.html": ["extras/gitrepository.html"],
+    "extras/gitrepository_update.html": ["extras/gitrepository_object_edit.html"],
+    "extras/graphqlquery_retrieve.html": ["extras/graphqlquery.html"],
+    "extras/jobresult_retrieve.html": ["extras/jobresult.html"],
+    "extras/note_retrieve.html": ["extras/note.html"],
+    "extras/objectchange_retrieve.html": ["extras/objectchange.html"],
+    "extras/secretsgroup_update.html": ["extras/secretsgroup_edit.html"],
+    "extras/tag_update.html": ["extras/tag_edit.html"],
+    "generic/object_bulk_create.html": ["generic/object_bulk_import.html"],
+    "generic/object_bulk_destroy.html": ["generic/object_bulk_delete.html"],
+    "generic/object_bulk_update.html": ["generic/object_bulk_edit.html"],
+    "generic/object_changelog.html": ["extras/object_changelog.html"],
+    "generic/object_create.html": ["dcim/powerpanel_edit.html", "generic/object_edit.html", "ipam/service_edit.html"],
+    "generic/object_destroy.html": ["generic/object_delete.html"],
+    "generic/object_notes.html": ["extras/object_notes.html"],
+    "generic/object_retrieve.html": [
+        "circuits/circuit.html",
+        "circuits/circuit_retrieve.html",
+        "circuits/circuittermination.html",
+        "circuits/circuittermination_retrieve.html",
+        "circuits/circuittype.html",
+        "circuits/circuittype_retrieve.html",
+        "circuits/providernetwork.html",
+        "circuits/providernetwork_retrieve.html",
+        "cloud/cloudaccount_retrieve.html",
+        "cloud/cloudnetwork_retrieve.html",
+        "cloud/cloudresourcetype_retrieve.html",
+        "cloud/cloudservice_retrieve.html",
+        "dcim/controller/base.html",
+        "dcim/controller_retrieve.html",
+        "dcim/controller_wirelessnetworks.html",
+        "dcim/controllermanageddevicegroup_retrieve.html",
+        "dcim/device/base.html",
+        "dcim/device/consoleports.html",
+        "dcim/device/consoleserverports.html",
+        "dcim/device/devicebays.html",
+        "dcim/device/frontports.html",
+        "dcim/device/interfaces.html",
+        "dcim/device/inventory.html",
+        "dcim/device/modulebays.html",
+        "dcim/device/poweroutlets.html",
+        "dcim/device/powerports.html",
+        "dcim/device/rearports.html",
+        "dcim/device/wireless.html",
+        "dcim/devicefamily_retrieve.html",
+        "dcim/deviceredundancygroup_retrieve.html",
+        "dcim/devicetype.html",
+        "dcim/devicetype_retrieve.html",
+        "dcim/interfaceredundancygroup_retrieve.html",
+        "dcim/locationtype.html",
+        "dcim/locationtype_retrieve.html",
+        "dcim/manufacturer.html",
+        "dcim/platform.html",
+        "dcim/powerfeed.html",
+        "dcim/powerfeed_retrieve.html",
+        "dcim/powerpanel.html",
+        "dcim/powerpanel_retrieve.html",
+        "dcim/rackgroup.html",
+        "dcim/softwareimagefile_retrieve.html",
+        "dcim/softwareversion_retrieve.html",
+        "dcim/virtualchassis.html",
+        "dcim/virtualchassis_retrieve.html",
+        "dcim/virtualdevicecontext_retrieve.html",
+        "extras/computedfield.html",
+        "extras/computedfield_retrieve.html",
+        "extras/configcontext.html",
+        "extras/configcontext_retrieve.html",
+        "extras/contact_retrieve.html",
+        "extras/customfield.html",
+        "extras/customfield_retrieve.html",
+        "extras/customlink.html",
+        "extras/exporttemplate.html",
+        "extras/job_detail.html",
+        "extras/jobbutton_retrieve.html",
+        "extras/jobhook.html",
+        "extras/jobqueue_retrieve.html",
+        "extras/metadatatype_retrieve.html",
+        "extras/secretsgroup.html",
+        "extras/secretsgroup_retrieve.html",
+        "extras/status.html",
+        "extras/tag.html",
+        "extras/tag_retrieve.html",
+        "extras/team_retrieve.html",
+        "generic/object_detail.html",
+        "ipam/rir.html",
+        "ipam/service.html",
+        "ipam/service_retrieve.html",
+        "ipam/vlan.html",
+        "ipam/vlan_retrieve.html",
+        "ipam/vlangroup.html",
+        "tenancy/tenant.html",
+        "virtualization/clustergroup.html",
+        "virtualization/clustertype.html",
+        "virtualization/virtualmachine.html",
+        "virtualization/virtualmachine_retrieve.html",
+        "wireless/radioprofile_retrieve.html",
+        "wireless/supporteddatarate_retrieve.html",
+        "wireless/wirelessnetwork_retrieve.html",
+    ],
+    "ipam/prefix_retrieve.html": ["ipam/prefix.html"],
+    "ipam/vlan_update.html": ["ipam/vlan_edit.html"],
+    "tenancy/tenant_create.html": ["tenancy/tenant_edit.html"],
+    "tenancy/tenantgroup_retrieve.html": ["tenancy/tenantgroup.html"],
+    "virtualchassis_update.html": ["dcim/virtualchassis_edit.html"],
+    "virtualization/virtualmachine_update.html": ["virtualization/virtualmachine_edit.html"],
+}
+
+
+def replace_template_references(content: str) -> tuple[str, bool]:
+    """
+    Replaces references to deprecated templates with new ones.
+
+    Args:
+        content: The content of the file to replace references in.
+
+    Returns:
+        A tuple containing the updated content and a boolean indicating if any changes were made.
+    """
+    for new_template, old_templates in TEMPLATE_REPLACEMENTS.items():
+        for old_template in old_templates:
+            pattern = rf"(\{{%\s*extends\s*['\"]){re.escape(old_template)}(['\"]\s*%\}})"
+            new_content, count = re.subn(pattern, rf"\1{new_template}\2", content)
+            if count > 0:
+                # A django template can only have one extends statement, so we can return as soon as we find a match.
+                return new_content, True
+
+    return content, False
+
+
+def replace_deprecated_templates(path: str, dry_run: bool = False):
+    """
+    Recursively finds all .html files in the given directory,
+    and replaces references to deprecated templates with new ones.
+    """
+
+    if os.path.isfile(path):
+        only_filename = os.path.basename(path)
+        path = os.path.dirname(path)
+    else:
+        only_filename = None
+
+    for root, _, files in os.walk(path):
+        for filename in files:
+            if only_filename and only_filename != filename:
+                continue
+            if filename.endswith((".html")):
+                file_path = os.path.join(root, filename)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    original_content = f.read()
+
+                content = original_content
+
+                fixed_content, was_updated = replace_template_references(content)
+
+                if was_updated:
+                    if dry_run:
+                        print(f"Detected deprecated template reference in {file_path}")
+                        continue
+                    with open(file_path, "w", encoding="utf-8") as f:
+                        f.write(fixed_content)
+                    print(f"Updated: {file_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Replace deprecated templates with new ones")
+    parser.add_argument("path", type=str, help="Path to directory in which to recursively fix all .html files.")
+    parser.add_argument("--dry-run", action="store_true", help="Do not make any changes to the files.")
+    args = parser.parse_args()
+
+    replace_deprecated_templates(args.path, args.dry_run)
+
+
+if __name__ == "__main__":
+    main()

nautobot/core/jobs/__init__.py

@@ -19,7 +19,7 @@ from nautobot.core.celery import app, register_jobs
 from nautobot.core.exceptions import AbortTransaction
 from nautobot.core.jobs.bulk_actions import BulkDeleteObjects, BulkEditObjects
 from nautobot.core.jobs.cleanup import LogsCleanup
-from nautobot.core.jobs.groups import RefreshDynamicGroupCaches
+from nautobot.core.jobs.groups import RefreshDynamicGroupCacheJobButtonReceiver, RefreshDynamicGroupCaches
 from nautobot.core.utils.lookup import get_filterset_for_model
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params
 from nautobot.extras.datasources import (
@@ -381,5 +381,6 @@ jobs = [
     ImportObjects,
     LogsCleanup,
     RefreshDynamicGroupCaches,
+    RefreshDynamicGroupCacheJobButtonReceiver,
 ]
 register_jobs(*jobs)

nautobot/core/jobs/groups.py

@@ -1,5 +1,5 @@
 from nautobot.extras.choices import DynamicGroupTypeChoices
-from nautobot.extras.jobs import Job, ObjectVar
+from nautobot.extras.jobs import Job, JobButtonReceiver, ObjectVar
 from nautobot.extras.models import DynamicGroup
 
 name = "System Jobs"
@@ -31,8 +31,38 @@ class RefreshDynamicGroupCaches(Job):
         if single_group is not None:
             groups = groups.filter(pk=single_group.pk)
 
+        if not groups.exists():
+            self.logger.info("No relevant dynamic groups were specified, nothing to do.")
+            return
+
+        self.logger.info("Re-calculating and re-caching group members. This may take some time.")
         for group in groups:
             group.update_cached_members()
             self.logger.info("Cache refreshed successfully, now with %d members", group.count, extra={"object": group})
 
         self.logger.info("Cache(s) refreshed")
+
+
+class RefreshDynamicGroupCacheJobButtonReceiver(JobButtonReceiver):
+    """
+    System Job Button Receiver to re-calculate and re-cache the members of a given Dynamic Group.
+    """
+
+    class Meta:
+        name = "Refresh Dynamic Group Cache (Job Button Receiver)"
+        description = "Re-calculate and re-cache the membership list of a given Dynamic Group."
+
+    def receive_job_button(self, obj):
+        if not isinstance(obj, DynamicGroup):
+            self.fail("This job button should only be used with Dynamic Group records.")
+        elif obj.group_type == DynamicGroupTypeChoices.TYPE_STATIC:
+            self.fail(
+                "The members of this Dynamic Group are statically defined and do not need to be recalculated.",
+                extra={"object": obj},
+            )
+        else:
+            self.logger.info(
+                "Re-calculating and re-caching group members. This may take some time.", extra={"object": obj}
+            )
+            obj.update_cached_members()
+            self.logger.success("Cache refreshed successfully, now with %d members", obj.count, extra={"object": obj})

nautobot/core/models/tree_queries.py

@@ -1,3 +1,5 @@
+import uuid
+
 from django.core.cache import cache
 from django.db.models import Case, When
 from django.db.models.signals import post_delete, post_save
@@ -20,15 +22,18 @@ class TreeQuerySet(TreeQuerySet_, querysets.RestrictedQuerySet):
         Dynamically computes ancestors either through the tree or through the `parent` foreign key depending on whether
         tree fields are present on `of`.
         """
+
+        # If `of` is a UUID, i.e. pk, retrieve the corresponding model instance with tree fields disabled.
+        if isinstance(of, uuid.UUID):
+            of = self.model.objects.without_tree_fields().get(pk=of)
+
         # If `of` has `tree_depth` defined, i.e. if it was retrieved from the database on a queryset where tree fields
         # were enabled (see `TreeQuerySet.with_tree_fields` and `TreeQuerySet.without_tree_fields`), use the default
         # implementation from `tree_queries.query.TreeQuerySet`.
-        # Furthermore, if `of` doesn't have a parent field we also have to defer to the tree-based implementation which
-        # will then annotate the tree fields and proceed as usual.
-        if hasattr(of, "tree_depth") or not hasattr(of, "parent"):
+        if hasattr(of, "tree_depth"):
             return super().ancestors(of, include_self=include_self)
+
         # In the other case, traverse the `parent` foreign key until the root.
-        model_class = of._meta.concrete_model
         ancestor_pks = []
         if include_self:
             ancestor_pks.append(of.pk)
@@ -39,7 +44,7 @@ class TreeQuerySet(TreeQuerySet_, querysets.RestrictedQuerySet):
         # Reference:
         # https://stackoverflow.com/questions/4916851/django-get-a-queryset-from-array-of-ids-in-specific-order
         preserve_order = Case(*[When(pk=pk, then=position) for position, pk in enumerate(ancestor_pks)])
-        return model_class.objects.without_tree_fields().filter(pk__in=ancestor_pks).order_by(preserve_order)
+        return self.model.objects.without_tree_fields().filter(pk__in=ancestor_pks).order_by(preserve_order)
 
     def max_tree_depth(self):
         r"""

nautobot/core/signals.py

@@ -67,10 +67,21 @@ def invalidate_max_depth_cache(sender, **kwargs):
 
     Note that this signal is connected in `TreeModel.__init_subclass__()` so as to only apply to those models.
     """
-    from nautobot.core.models.tree_queries import TreeManager
+    from nautobot.core.models.tree_queries import TreeManager, TreeNode
 
     if not isinstance(sender.objects, TreeManager):
         return
 
+    # If the instance is a TreeNode, and it has siblings, skip invalidating the cache.
+    instance = kwargs.get("instance", None)
+    if isinstance(instance, TreeNode):
+        try:
+            parent = getattr(instance, "parent", None)
+        except instance.DoesNotExist:
+            parent = None
+        if parent and getattr(parent, "children", None) and parent.children.count() > 1:
+            # TreeNode has siblings, depth can't change
+            return
+
     with contextlib.suppress(redis.exceptions.ConnectionError):
         cache.delete(sender.objects.max_depth_cache_key)

nautobot/core/templates/components/panel/panel.html

@@ -1,4 +1,4 @@
-<div class="panel panel-default">
+<div class="panel panel-{{ css_class|default:"default"}}">
     {% if label.strip or header_extra_content.strip %}
         <div class="panel-heading">
             {% if label %}

nautobot/core/templates/inc/image_attachments.html

@@ -1,3 +1,4 @@
+{% comment %}3.0 TODO: Potentially remove this template pending no other references to it.{% endcomment %}
 {% if images %}
     <table class="table table-hover panel-body">
         <tr>
@@ -33,4 +34,4 @@
     <div class="panel-body">
         <span class="text-muted">None</span>
     </div>
-{% endif %}
+{% endif %}

nautobot/core/templatetags/helpers.py

@@ -14,9 +14,11 @@ from django.contrib.staticfiles.finders import find
 from django.core.exceptions import ObjectDoesNotExist
 from django.templatetags.static import static, StaticNode
 from django.urls import NoReverseMatch, reverse
+from django.utils.formats import date_format
 from django.utils.html import format_html, format_html_join, strip_tags
 from django.utils.safestring import mark_safe
 from django.utils.text import slugify as django_slugify
+from django.utils.translation import gettext as _
 from django_jinja import library
 from markdown import markdown
 import yaml
@@ -831,6 +833,26 @@ def label_list(value, suffix=""):
     )
 
 
+@library.filter()
+@register.filter()
+def format_timezone(time_zone):
+    """
+    Return a human-readable representation of a time zone including:
+      - Time zone name and UTC offset on the first line
+      - Local date and time on the next line (in smaller font)
+    """
+    if not time_zone:
+        return HTML_NONE
+
+    now = datetime.datetime.now(time_zone)
+
+    # Locale-aware formatting (respects USE_L10N + active locale)
+    local_time = date_format(now, format="DATETIME_FORMAT", use_l10n=True)
+
+    result = f"{time_zone} (UTC {now.strftime('%z')})<br><small>{_('Local time')}: {local_time}</small>"
+    return format_html(result)
+
+
 #
 # Tags
 #

nautobot/core/tests/runner.py

@@ -157,6 +157,9 @@ class NautobotTestRunner(DiscoverRunner):
                             db_command = [*command, "--database", alias]
                             call_command(*db_command)
 
+                        # Calculate membership for the dynamic groups that were generated by the factories/fixtures
+                        call_command("refresh_dynamic_group_member_caches")
+
                     if self.parallel > 1:
                         for index in range(self.parallel):
                             with time_keeper.timed(f"  Cloning '{alias}'"):

nautobot/core/tests/test_cli.py

@@ -0,0 +1,40 @@
+from nautobot.core.cli import migrate_deprecated_templates
+from nautobot.core.testing import TestCase
+
+
+class TestMigrateTemplates(TestCase):
+    def test_template_replacements(self):
+        """Verify that all old templates are replaced by a single new template."""
+        audit_dict = {}
+        for new_template, old_templates in migrate_deprecated_templates.TEMPLATE_REPLACEMENTS.items():
+            for old_template in old_templates:
+                self.assertNotIn(old_template, audit_dict)
+                audit_dict[old_template] = new_template
+
+    def test_replace_template_references_no_change(self):
+        content = """
+        {% extends "base.html" %}
+        {% block content %}
+        <h1>Hello, World!</h1>
+        {% endblock %}
+        """
+        replaced_content, was_updated = migrate_deprecated_templates.replace_template_references(content)
+        self.assertFalse(was_updated)
+        self.assertEqual(replaced_content, content)
+
+    def test_replace_template_references(self):
+        original_content = """
+        {% extends "generic/object_bulk_import.html" %}
+        {% block content %}
+        <h1>Hello, World!</h1>
+        {% endblock %}
+        """
+        new_content = """
+        {% extends "generic/object_bulk_create.html" %}
+        {% block content %}
+        <h1>Hello, World!</h1>
+        {% endblock %}
+        """
+        replaced_content, was_updated = migrate_deprecated_templates.replace_template_references(original_content)
+        self.assertTrue(was_updated)
+        self.assertEqual(replaced_content, new_content)

nautobot/core/tests/test_forms.py

@@ -1,14 +1,19 @@
+import inspect
+import sys
 from unittest import mock
 
 from django import forms as django_forms
+from django.apps import apps as django_apps
 from django.contrib.contenttypes.models import ContentType
 from django.http import QueryDict
 from django.test import TestCase
 from django.urls import reverse
+from django_filters.filterset import FilterSet
 from netaddr import IPNetwork
 
 from nautobot.core import filters, forms, testing
 from nautobot.core.utils import requests
+from nautobot.core.utils.filtering import get_filterset_parameter_form_field
 from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models
 from nautobot.dcim.tests import test_views
 from nautobot.extras import filters as extras_filters, models as extras_models
@@ -624,6 +629,42 @@ class WidgetsTest(TestCase):
 
 
 class DynamicFilterFormTest(TestCase):
+    def test_get_filterset_parameter_form_field_all_filters(self):
+        """
+        Test every FilterSet to validate that Plural names are correctly mapped in get_filterset_parameter_form_field.
+        """
+        filterset_classes = set()
+        for app_config in django_apps.get_app_configs():
+            try:
+                filters_mod = sys.modules.get(f"{app_config.name}.filters")
+                if not filters_mod:
+                    continue
+                for _name, obj in inspect.getmembers(filters_mod):
+                    if (
+                        inspect.isclass(obj)  # Check if obj is a class
+                        and issubclass(obj, FilterSet)  # Check if obj is a subclass of FilterSet
+                        and obj is not FilterSet  # Exclude the base FilterSet class itself
+                        and getattr(getattr(obj, "_meta", None), "model", None)
+                        is not None  # Ensure the FilterSet has a model defined
+                    ):
+                        filterset_classes.add(obj)
+            except Exception as e:
+                # This test might start failing if an app's filters.py gets a design change.
+                self.fail(f"Error processing app '{app_config.name}': {e}")
+        for filterset_class in filterset_classes:
+            filterset = filterset_class()
+            model = filterset._meta.model
+            for filter_name in filterset.filters.keys():
+                try:
+                    field = get_filterset_parameter_form_field(model, filter_name, filterset=filterset)
+                    self.assertIsNotNone(field, "Field was unexpectedly None")
+                except KeyError as e:
+                    self.fail(
+                        f"A filter failed to operate due to mismatched plural name:"
+                        f" Check MODEL_VERBOSE_NAME_PLURAL_TO_FEATURE_NAME_MAPPING:"
+                        f" FilterClass: {filterset_class.__name__} name: {filter_name}: {e}"
+                    )
+
     # TODO(timizuo): investigate why test fails on CI
     # def test_dynamic_filter_form_with_missing_attr(self):
     #     with self.assertRaises(AttributeError) as err:

nautobot/core/tests/test_jobs.py

@@ -17,11 +17,12 @@ from nautobot.core.jobs.cleanup import CleanupTypes
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
 from nautobot.core.testing.context import load_event_broker_override_settings
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
-from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.choices import DynamicGroupTypeChoices, JobResultStatusChoices, LogLevelChoices
 from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
 from nautobot.extras.models import (
     Contact,
     ContactAssociation,
+    DynamicGroup,
     ExportTemplate,
     FileProxy,
     JobLogEntry,
@@ -1248,3 +1249,76 @@ class BulkDeleteTestCase(TransactionTestCase):
             saved_view_id=None,
         )
         self._common_no_error_test_assertion(Role, job_result, name__istartswith="Example Status")
+
+
+class RefreshDynamicGroupCacheJobButtonReceiverTestCase(TransactionTestCase):
+    def setUp(self):
+        super().setUp()
+        self.job_module = "nautobot.core.jobs.groups"
+        self.job_name = "RefreshDynamicGroupCacheJobButtonReceiver"
+
+    def test_successful_cache_refresh(self):
+        LocationType.objects.create(name="DG Test LT 1")
+        LocationType.objects.create(name="DG Test LT 2")
+        LocationType.objects.create(name="DG Test LT 3")
+        dg = DynamicGroup(
+            name="Location Types",
+            content_type=ContentType.objects.get_for_model(LocationType),
+            group_type=DynamicGroupTypeChoices.TYPE_DYNAMIC_FILTER,
+            filter={"name__isw": ["DG Test"]},
+        )
+        dg.clean()
+        dg.save(update_cached_members=False)
+        self.assertEqual(0, dg.count)
+
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.dynamicgroup",
+            object_pk=dg.pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(3, dg.count)
+
+        dg.filter = {"name__iew": ["DG Test"]}
+        dg.clean()
+        dg.save(update_cached_members=False)
+        self.assertEqual(3, dg.count)
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.dynamicgroup",
+            object_pk=dg.pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(0, dg.count)
+
+    def test_failure_on_non_dg(self):
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.status",
+            object_pk=Status.objects.first().pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+        log_fail = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+        self.assertEqual(log_fail.message, "This job button should only be used with Dynamic Group records.")
+
+    def test_failure_on_static_dg(self):
+        dg = DynamicGroup.objects.create(
+            name="Location Types",
+            content_type=ContentType.objects.get_for_model(LocationType),
+            group_type=DynamicGroupTypeChoices.TYPE_STATIC,
+        )
+        job_result = create_job_result_and_run_job(
+            self.job_module,
+            self.job_name,
+            object_model_name="extras.dynamicgroup",
+            object_pk=dg.pk,
+        )
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+        log_fail = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+        self.assertEqual(
+            log_fail.message,
+            "The members of this Dynamic Group are statically defined and do not need to be recalculated.",
+        )

nautobot/core/tests/test_tree_queries.py

@@ -13,8 +13,21 @@ class TestInvalidateMaxTreeDepthSignal(TestCase):
         # Ensure that the max_depth hasn't already been cached
         Location.objects.__dict__.pop("max_depth", None)
         location = Location.objects.first()
-        with self.assertNumQueries(1):
+
+        with CaptureQueriesContext(connection) as ctx:
             location.save()
+            captured_tree_cte_queries = [
+                query["sql"] for query in ctx.captured_queries if "WITH RECURSIVE" in query["sql"]
+            ]
+        allowed_number_of_tree_queries = 0  # We don't expect any tree queries to be run
+        _query_separator = "\n" + ("-" * 10) + "\n" + "NEXT QUERY" + "\n" + ("-" * 10)
+        self.assertEqual(
+            len(captured_tree_cte_queries),
+            allowed_number_of_tree_queries,
+            f"The CTE tree was calculated a different number of times ({len(captured_tree_cte_queries)})"
+            f" than allowed ({allowed_number_of_tree_queries})."
+            f" The following queries were used:\n{_query_separator.join(captured_tree_cte_queries)}",
+        )
 
 
 class QuerySetAncestorTests(TestCase):