nautobot 2.4.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

nautobot/core/celery/schedulers.py

@@ -128,7 +128,7 @@ class NautobotDatabaseScheduler(DatabaseScheduler):
                 scheduled_job = entry.model
                 job_queue = scheduled_job.job_queue
                 # Distinguish between Celery and Kubernetes job queues
-                if job_queue.queue_type == JobQueueTypeChoices.TYPE_KUBERNETES:
+                if job_queue is not None and job_queue.queue_type == JobQueueTypeChoices.TYPE_KUBERNETES:
                     job_result = JobResult.objects.create(
                         name=scheduled_job.job_model.name,
                         job_model=scheduled_job.job_model,

nautobot/core/filters.py

@@ -13,6 +13,7 @@ from django_filters.constants import EMPTY_VALUES
 from django_filters.utils import get_model_field, label_for_filter, resolve_field, verbose_lookup_expr
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
+import timezone_field
 
 from nautobot.core import constants, forms
 from nautobot.core.forms import widgets
@@ -612,9 +613,12 @@ class BaseFilterSet(django_filters.FilterSet):
             models.UUIDField: {"filter_class": MultiValueUUIDFilter},
             core_fields.MACAddressCharField: {"filter_class": MultiValueMACAddressFilter},
             core_fields.TagsField: {"filter_class": TagFilter},
+            timezone_field.TimeZoneField: {"filter_class": MultiValueCharFilter},
         }
     )
 
+    USE_CHAR_FILTER_FOR_LOOKUPS = [django_filters.MultipleChoiceFilter]
+
     @staticmethod
     def _get_filter_lookup_dict(existing_filter):
         # Choose the lookup expression map based on the filter type
@@ -678,8 +682,7 @@ class BaseFilterSet(django_filters.FilterSet):
             return magic_filters
 
         # Get properties of the existing filter for later use
-        field_name = filter_field.field_name
-        field = get_model_field(cls._meta.model, field_name)  # pylint: disable=no-member
+        field = get_model_field(cls._meta.model, filter_field.field_name)  # pylint: disable=no-member
 
         # If there isn't a model field, return.
         if field is None:
@@ -696,25 +699,7 @@ class BaseFilterSet(django_filters.FilterSet):
             new_filter_name = f"{filter_name}__{lookup_name}"
 
             try:
-                if filter_name in cls.declared_filters and lookup_expr not in {"isnull"}:  # pylint: disable=no-member
-                    # The filter field has been explicitly defined on the filterset class so we must manually
-                    # create the new filter with the same type because there is no guarantee the defined type
-                    # is the same as the default type for the field. This does not apply if the filter
-                    # should retain the original lookup_expr type, such as `isnull` using a boolean field on a
-                    # char or date object.
-                    resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
-                    new_filter = type(filter_field)(
-                        field_name=field_name,
-                        lookup_expr=lookup_expr,
-                        label=filter_field.label,
-                        exclude=filter_field.exclude,
-                        distinct=filter_field.distinct,
-                        **filter_field.extra,
-                    )
-                else:
-                    # The filter field is listed in Meta.fields so we can safely rely on default behavior
-                    # Will raise FieldLookupError if the lookup is invalid
-                    new_filter = cls.filter_for_field(field, field_name, lookup_expr)
+                new_filter = cls._get_new_filter(filter_field, field, filter_name, lookup_expr)
             except django_filters.exceptions.FieldLookupError:
                 # The filter could not be created because the lookup expression is not supported on the field
                 continue
@@ -743,6 +728,45 @@ class BaseFilterSet(django_filters.FilterSet):
 
         return magic_filters
 
+    @classmethod
+    def _should_use_char_filter_for_lookups(cls, filter_field):
+        return type(filter_field) in cls.USE_CHAR_FILTER_FOR_LOOKUPS
+
+    @classmethod
+    def _get_new_filter(cls, filter_field, field, filter_name, lookup_expr):
+        if cls._should_use_char_filter_for_lookups(filter_field):
+            # For some cases like `MultiValueChoiceFilter(django_filters.MultipleChoiceFilter)`
+            # we want to have choices field with no lookups and standard char field for lookups filtering.
+            # Using a `choice` field for lookups blocks us from using `__re`, `__iew` or other "partial" filters.
+            resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
+            return MultiValueCharFilter(
+                field_name=filter_field.field_name,
+                lookup_expr=lookup_expr,
+                label=filter_field.label,
+                exclude=filter_field.exclude,
+                distinct=filter_field.distinct,
+            )
+
+        if filter_name in cls.declared_filters and lookup_expr not in {"isnull"}:  # pylint: disable=no-member
+            # The filter field has been explicitly defined on the filterset class so we must manually
+            # create the new filter with the same type because there is no guarantee the defined type
+            # is the same as the default type for the field. This does not apply if the filter
+            # should retain the original lookup_expr type, such as `isnull` using a boolean field on a
+            # char or date object.
+            resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
+            return type(filter_field)(
+                field_name=filter_field.field_name,
+                lookup_expr=lookup_expr,
+                label=filter_field.label,
+                exclude=filter_field.exclude,
+                distinct=filter_field.distinct,
+                **filter_field.extra,
+            )
+
+        # The filter field is listed in Meta.fields so we can safely rely on default behavior
+        # Will raise FieldLookupError if the lookup is invalid
+        return cls.filter_for_field(field, filter_field.field_name, lookup_expr)
+
     @classmethod
     def add_filter(cls, new_filter_name, new_filter_field):
         """
@@ -850,7 +874,10 @@ class BaseFilterSet(django_filters.FilterSet):
         Note: Any CharField or IntegerField with choices set is a ChoiceField.
         """
         if lookup_type == "exact" and getattr(field, "choices", None):
+            if isinstance(field, timezone_field.TimeZoneField):
+                return django_filters.MultipleChoiceFilter, {"choices": ((str(v), n) for v, n in field.choices)}
             return django_filters.MultipleChoiceFilter, {"choices": field.choices}
+
         return super().filter_for_lookup(field, lookup_type)
 
     def __init__(self, data=None, queryset=None, *, request=None, prefix=None):

nautobot/core/jobs/bulk_actions.py

@@ -7,7 +7,9 @@ from django.core.exceptions import (
 )
 from django.db.models import ManyToManyField, ProtectedError
 
+from nautobot.core import exceptions
 from nautobot.core.forms.utils import restrict_form_fields
+from nautobot.core.utils.filtering import get_filterset_field
 from nautobot.core.utils.lookup import get_filterset_for_model, get_form_for_model
 from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
 from nautobot.extras.jobs import (
@@ -42,15 +44,33 @@ class BulkEditObjects(Job):
 
     def _update_objects(self, model, form, filter_query_params, edit_all, nullified_fields):
         with deferred_change_logging_for_bulk_operation():
+            base_queryset = model.objects.restrict(self.user, "change")
             updated_objects_pk = []
             filterset_cls = get_filterset_for_model(model)
 
-            if filter_query_params and not filterset_cls:
-                self.logger.error(f"Filterset not found for {model}")
-                raise RunJobTaskFailed(f"Filter query provided but {model} do not have a filterset.")
+            if filter_query_params:
+                if not filterset_cls:
+                    self.logger.error(f"Filterset not found for {model._meta.verbose_name}")
+                    raise RunJobTaskFailed(
+                        f"Filter query provided but {model._meta.verbose_name} does not have a filterset."
+                    )
+
+                # Discarding non-filter query params
+                new_filter_query_params = {}
+
+                for key, value in filter_query_params.items():
+                    try:
+                        get_filterset_field(filterset_cls(), key)
+                        new_filter_query_params[key] = value
+                    except exceptions.FilterSetFieldNotFound:
+                        self.logger.debug(
+                            f"Query parameter `{key}` not found in filterset for `{filterset_cls}`, discarding it"
+                        )
+
+                filter_query_params = new_filter_query_params
 
             if edit_all:
-                if filterset_cls and filter_query_params:
+                if filter_query_params:
                     queryset = filterset_cls(filter_query_params).qs.restrict(self.user, "change")
                 else:
                     queryset = model.objects.restrict(self.user, "change")
@@ -93,7 +113,7 @@ class BulkEditObjects(Job):
 
                 # Update custom fields
                 for field_name in form_custom_fields:
-                    if field_name in form.nullable_fields and field_name in nullified_fields:
+                    if field_name in form.nullable_fields and nullified_fields and field_name in nullified_fields:
                         obj.cf[remove_prefix_from_cf_key(field_name)] = None
                     elif form.cleaned_data.get(field_name) not in (None, "", []):
                         obj.cf[remove_prefix_from_cf_key(field_name)] = form.cleaned_data[field_name]
@@ -111,7 +131,7 @@ class BulkEditObjects(Job):
                     form.save_note(instance=obj, user=self.user)
             total_updated_objs = len(updated_objects_pk)
             # Enforce object-level permissions
-            if queryset.filter(pk__in=updated_objects_pk).count() != total_updated_objs:
+            if base_queryset.filter(pk__in=updated_objects_pk).count() != total_updated_objs:
                 raise ObjectDoesNotExist
             return total_updated_objs
 
@@ -201,33 +221,49 @@ class BulkDeleteObjects(Job):
             )
             raise RunJobTaskFailed("Model not found")
 
-        if pk_list and (delete_all or filter_query_params):
-            self.logger.error(
-                "You can either delete objs within `pk_list` provided or `delete_all` with `filter_query_params` if needed."
-            )
-            raise RunJobTaskFailed("Both `pk_list` and `delete_all` can not both be set.")
-
         filterset_cls = get_filterset_for_model(model)
 
-        if filter_query_params and not filterset_cls:
-            self.logger.error(f"Filterset not found for {model}")
-            raise RunJobTaskFailed(f"Filter query provided but {model} do not have a filterset.")
+        if filter_query_params:
+            if not filterset_cls:
+                self.logger.error(f"Filterset not found for {model._meta.verbose_name}")
+                raise RunJobTaskFailed(
+                    f"Filter query provided but {model._meta.verbose_name} does not have a filterset."
+                )
+
+            # Discarding non-filter query params
+            new_filter_query_params = {}
+
+            for key, value in filter_query_params.items():
+                try:
+                    get_filterset_field(filterset_cls(), key)
+                    new_filter_query_params[key] = value
+                except exceptions.FilterSetFieldNotFound:
+                    self.logger.debug(f"Query parameter `{key}` not found in `{filterset_cls}`, discarding it")
+
+            filter_query_params = new_filter_query_params
 
         if delete_all:
-            if filterset_cls and filter_query_params:
+            # Case for selecting all objects (or all filtered objects) to delete
+            if filter_query_params:
+                # If there is filter query params, we need to apply it to the queryset
                 queryset = filterset_cls(filter_query_params).qs.restrict(self.user, "delete")
                 # We take this approach because filterset.qs has already applied .distinct(),
                 # and performing a .delete directly on a queryset with .distinct applied is not allowed.
                 queryset = model.objects.filter(pk__in=queryset)
             else:
+                # If there is not, we can just restrict the queryset to the user's permissions
                 queryset = model.objects.restrict(self.user, "delete")
-        else:
+        elif pk_list:
+            # Case for selecting specific objects to delete, delete_all overrides this option
             queryset = model.objects.restrict(self.user, "delete").filter(pk__in=pk_list)
             if queryset.count() < len(pk_list):
                 # We do not check ObjectPermission error for `delete_all` case because user is trying to
                 # delete all objs they have permission to which would not raise any issue.
                 self.logger.error("You do not have permissions to delete some of the objects provided in `pk_list`.")
                 raise RunJobTaskFailed("Caught ObjectPermission error while attempting to delete objects")
+        elif not pk_list and not delete_all:
+            self.logger.error("You must select at least one object instance to delete.")
+            raise RunJobTaskFailed("Either `pk_list` or `delete_all` is required.")
 
         verbose_name_plural = model._meta.verbose_name_plural
 
@@ -240,9 +276,10 @@ class BulkDeleteObjects(Job):
         try:
             self.logger.info(f"Deleting {queryset.count()} {verbose_name_plural}...")
             _, deleted_info = bulk_delete_with_bulk_change_logging(queryset)
-            deleted_count = deleted_info[model._meta.label]
+            deleted_count = deleted_info.get(model._meta.label, 0)
         except ProtectedError as err:
-            self.logger.error(f"Caught ProtectedError while attempting to delete objects: {err}")
+            # TODO this error message needs to be cleaner, ideally using a variant of handle_protectederror
+            self.logger.error(f"Caught ProtectedError while attempting to delete objects: `{err}`")
             raise RunJobTaskFailed("Caught ProtectedError while attempting to delete objects")
         msg = f"Deleted {deleted_count} {model._meta.verbose_name_plural}"
         self.logger.info(msg)

nautobot/core/models/__init__.py

@@ -248,6 +248,8 @@ class BaseModel(models.Model):
         Unlike `get_natural_key_def()`, this doesn't auto-exclude all AutoField and BigAutoField fields,
         but instead explicitly discounts the `id` field (only) as a candidate.
         """
+        if cls != cls._meta.concrete_model:
+            return cls._meta.concrete_model.natural_key_field_lookups
         # First, figure out which local fields comprise the natural key:
         natural_key_field_names = []
         if hasattr(cls, "natural_key_field_names"):

nautobot/core/tables.py

@@ -1,6 +1,7 @@
 import contextlib
 import logging
 
+from django.conf import settings
 from django.contrib.auth.models import AnonymousUser
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.core.exceptions import FieldDoesNotExist, FieldError
@@ -557,7 +558,10 @@ class LinkedCountColumn(django_tables2.Column):
                 related_record = related_records[0]
         url = reverse(self.viewname, kwargs=self.view_kwargs)
         if self.url_params:
-            url += "?" + urlencode({k: getattr(record, v) for k, v in self.url_params.items()})
+            url += "?" + urlencode(
+                # Replace None values with `FILTERS_NULL_CHOICE_VALUE` to handle URL parameters correctly
+                {k: (getattr(record, v) or settings.FILTERS_NULL_CHOICE_VALUE) for k, v in self.url_params.items()}
+            )
         if value > 1:
             return format_html('<a href="{}" class="badge">{}</a>', url, value)
         if related_record is not None:

nautobot/core/testing/filters.py

@@ -1,6 +1,6 @@
 import random
 import string
-from typing import ClassVar, Iterable
+from typing import ClassVar, Iterable, Optional
 
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Count, Q, QuerySet
@@ -30,7 +30,7 @@ class FilterTestCases:
     class BaseFilterTestCase(views.TestCase):
         """Base class for testing of FilterSets."""
 
-        queryset: ClassVar[QuerySet]
+        queryset: ClassVar[Optional[QuerySet]] = None  # TODO: declared as Optional only to avoid a breaking change
 
         def get_filterset_test_values(self, field_name, queryset=None):
             """Returns a list of distinct values from the requested queryset field to use in filterset tests.
@@ -73,7 +73,7 @@ class FilterTestCases:
     class FilterTestCase(BaseFilterTestCase):
         """Add common tests for all FilterSets."""
 
-        filterset: ClassVar[type[FilterSet]]
+        filterset: ClassVar[Optional[type[FilterSet]]] = None  # TODO: declared Optional only to avoid breaking change
 
         # filter predicate fields that should be excluded from q test case
         exclude_q_filter_predicates = []
@@ -85,7 +85,7 @@ class FilterTestCases:
         #       ["filter1"],
         #       ["filter2", "field2__name"],
         #   ]
-        generic_filter_tests: ClassVar[Iterable]
+        generic_filter_tests: ClassVar[Iterable] = ()
 
         def setUp(self):
             for attr in ["queryset", "filterset", "generic_filter_tests"]:
@@ -95,34 +95,38 @@ class FilterTestCases:
 
         def get_q_filter(self):
             """Helper method to return q filter."""
+            self.assertIsNotNone(self.filterset)
             return self.filterset.declared_filters["q"].filter_predicates
 
         def test_id(self):
             """Verify that the filterset supports filtering by id with only lookup `__n`."""
+            self.assertIsNotNone(self.filterset)
+
             with self.subTest("Assert `id`"):
                 params = {"id": list(self.queryset.values_list("pk", flat=True)[:2])}
                 expected_queryset = self.queryset.filter(id__in=params["id"])
-                filterset = self.filterset(params, self.queryset)
+                filterset = self.filterset(params, self.queryset)  # pylint: disable=not-callable  # see assertion above
                 self.assertTrue(filterset.is_valid())
                 self.assertQuerysetEqualAndNotEmpty(filterset.qs.order_by("id"), expected_queryset.order_by("id"))
 
             with self.subTest("Assert negate lookup"):
                 params = {"id__n": list(self.queryset.values_list("pk", flat=True)[:2])}
                 expected_queryset = self.queryset.exclude(id__in=params["id__n"])
-                filterset = self.filterset(params, self.queryset)
+                filterset = self.filterset(params, self.queryset)  # pylint: disable=not-callable  # see assertion above
                 self.assertTrue(filterset.is_valid())
                 self.assertQuerysetEqualAndNotEmpty(filterset.qs.order_by("id"), expected_queryset.order_by("id"))
 
             with self.subTest("Assert invalid lookup"):
                 params = {"id__in": list(self.queryset.values_list("pk", flat=True)[:2])}
-                filterset = self.filterset(params, self.queryset)
+                filterset = self.filterset(params, self.queryset)  # pylint: disable=not-callable  # see assertion above
                 self.assertFalse(filterset.is_valid())
                 self.assertIn("Unknown filter field", filterset.errors.as_text())
 
         def test_invalid_filter(self):
             """Verify that the filterset reports as invalid when initialized with an unsupported filter parameter."""
             params = {"ice_cream_flavor": ["chocolate"]}
-            self.assertFalse(self.filterset(params, self.queryset).is_valid())
+            self.assertIsNotNone(self.filterset)
+            self.assertFalse(self.filterset(params, self.queryset).is_valid())  # pylint: disable=not-callable
 
         def test_filters_generic(self):
             """Test all multiple choice filters declared in `self.generic_filter_tests`.
@@ -190,13 +194,16 @@ class FilterTestCases:
                         status=Status.objects.get_for_model(ContactAssociation).last(),
                     )
 
+            if self.generic_filter_tests:
+                self.assertIsNotNone(self.filterset)
+
             for test in self.generic_filter_tests:
                 filter_name = test[0]
                 field_name = test[-1]  # default to filter_name if a second list item was not supplied
                 with self.subTest(f"{self.filterset.__name__} filter {filter_name} ({field_name})"):
                     test_data = self.get_filterset_test_values(field_name)
                     params = {filter_name: test_data}
-                    filterset_result = self.filterset(params, self.queryset).qs
+                    filterset_result = self.filterset(params, self.queryset).qs  # pylint: disable=not-callable
                     qs_result = self.queryset.filter(**{f"{field_name}__in": test_data}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result, ordered=False)
 
@@ -207,6 +214,7 @@ class FilterTestCases:
             This test asserts that `filter=True` matches `self.queryset.filter(field__isnull=False)` and
             that `filter=False` matches `self.queryset.filter(field__isnull=True)`.
             """
+            self.assertIsNotNone(self.filterset)
             for filter_name, filter_object in self.filterset.get_filters().items():
                 if not isinstance(filter_object, RelatedMembershipBooleanFilter):
                     continue
@@ -214,11 +222,11 @@ class FilterTestCases:
                     continue
                 field_name = filter_object.field_name
                 with self.subTest(f"{self.filterset.__name__} RelatedMembershipBooleanFilter {filter_name} (True)"):
-                    filterset_result = self.filterset({filter_name: True}, self.queryset).qs
+                    filterset_result = self.filterset({filter_name: True}, self.queryset).qs  # pylint: disable=not-callable
                     qs_result = self.queryset.filter(**{f"{field_name}__isnull": filter_object.exclude}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
                 with self.subTest(f"{self.filterset.__name__} RelatedMembershipBooleanFilter {filter_name} (False)"):
-                    filterset_result = self.filterset({filter_name: False}, self.queryset).qs
+                    filterset_result = self.filterset({filter_name: False}, self.queryset).qs  # pylint: disable=not-callable
                     qs_result = self.queryset.exclude(**{f"{field_name}__isnull": filter_object.exclude}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
 
@@ -227,6 +235,8 @@ class FilterTestCases:
             if not issubclass(self.queryset.model, PrimaryModel):
                 self.skipTest("Not a PrimaryModel")
 
+            self.assertIsNotNone(self.filterset)
+
             # Find an instance with at least two tags (should be common given our factory design)
             for instance in list(self.queryset):
                 if len(instance.tags.all()) >= 2:
@@ -243,7 +253,7 @@ class FilterTestCases:
                 self.queryset.first().tags.add(test_tags_filter_a, test_tags_filter_b)
                 tags = [test_tags_filter_a, test_tags_filter_b]
             params = {"tags": [tags[0].name, tags[1].pk]}
-            filterset_result = self.filterset(params, self.queryset).qs
+            filterset_result = self.filterset(params, self.queryset).qs  # pylint: disable=not-callable
             # Tags is an AND filter not an OR filter
             qs_result = self.queryset.filter(tags=tags[0]).filter(tags=tags[1]).distinct()
             self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result)
@@ -294,6 +304,8 @@ class FilterTestCases:
             """
             self._assert_valid_filter_predicates(obj, obj_field_name)
 
+            self.assertIsNotNone(self.filterset)
+
             # Generic test only supports CharField or TextFields, skip all other types
             obj_field = obj._meta.get_field(obj_field_name)
             if not isinstance(obj_field, (CharField, TextField)):
@@ -313,7 +325,7 @@ class FilterTestCases:
                 lookup = randomized_attr_value[1:].upper()
                 model_queryset = self.queryset.filter(**{f"{filter_field_name}__icontains": lookup})
             params = {"q": lookup}
-            filterset_result = self.filterset(params, self.queryset)
+            filterset_result = self.filterset(params, self.queryset)  # pylint: disable=not-callable
 
             self.assertTrue(filterset_result.is_valid())
             self.assertQuerysetEqualAndNotEmpty(

nautobot/core/testing/integration.py

@@ -6,7 +6,9 @@ from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.functional import classproperty
 from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.wait import WebDriverWait
 from splinter.browser import Browser
+from splinter.exceptions import ElementDoesNotExist
 
 from nautobot.core import testing
 
@@ -20,6 +22,71 @@ SELENIUM_HOST = os.getenv("NAUTOBOT_SELENIUM_HOST", "host.docker.internal")
 LOGIN_URL = reverse(settings.LOGIN_URL)
 
 
+class ObjectsListMixin:
+    """
+    Helper class for easier testing and navigating on standard Nautobot objects list page.
+    """
+
+    def select_all_items(self):
+        self.browser.find_by_xpath('//*[@id="object_list_form"]//input[@class="toggle"]').click()
+
+    def select_one_item(self):
+        self.browser.find_by_xpath('//*[@id="object_list_form"]//input[@name="pk"]').click()
+
+    def click_bulk_delete(self):
+        self.browser.find_by_xpath(
+            '//*[@id="object_list_form"]//button[@type="submit"]/following-sibling::button[1]'
+        ).click()
+        self.browser.find_by_xpath('//*[@id="object_list_form"]//button[@name="_delete"]').click()
+
+    def click_bulk_edit(self):
+        self.browser.find_by_xpath('//*[@id="object_list_form"]//button[@type="submit"]').click()
+
+    @property
+    def objects_list_visible_items(self):
+        objects_table_container = self.browser.find_by_xpath('//*[@id="object_list_form"]/div[1]/div')
+        try:
+            objects_table = objects_table_container.find_by_tag("tbody")
+            return len(objects_table.find_by_tag("tr"))
+        except ElementDoesNotExist:
+            return 0
+
+    def apply_filter(self, field, value):
+        self.browser.find_by_xpath('//*[@id="id__filterbtn"]').click()
+        self.fill_filters_select2_field(field, value)
+        self.browser.find_by_xpath('//*[@id="default-filter"]//button[@type="submit"]').click()
+
+
+class BulkOperationsMixin:
+    def confirm_bulk_delete_operation(self):
+        self.browser.find_by_xpath('//button[@name="_confirm" and @type="submit"]').click()
+
+    def submit_bulk_edit_operation(self):
+        self.browser.find_by_xpath("//button[@name='_apply']", wait_time=5).click()
+
+    def wait_for_job_result(self):
+        end_statuses = ["Completed", "Failed"]
+        WebDriverWait(self.browser, 30).until(
+            lambda driver: driver.find_by_id("pending-result-label").text in end_statuses
+        )
+
+        return self.browser.find_by_id("pending-result-label").text
+
+    def verify_job_description(self, expected_job_description):
+        job_description = self.browser.find_by_xpath('//td[text()="Job Description"]/following-sibling::td[1]').text
+        self.assertEqual(job_description, expected_job_description)
+
+    def assertIsBulkDeleteJob(self):
+        self.verify_job_description("Bulk delete objects.")
+
+    def assertIsBulkEditJob(self):
+        self.verify_job_description("Bulk edit objects.")
+
+    def assertJobStatusIsCompleted(self):
+        job_status = self.wait_for_job_result()
+        self.assertEqual(job_status, "Completed")
+
+
 # In CI, sometimes the FQDN of SELENIUM_HOST gets used, other times it seems to be just the hostname?
 @override_settings(ALLOWED_HOSTS=["nautobot.example.com", SELENIUM_HOST, SELENIUM_HOST.split(".")[0]])
 @tag("integration")
@@ -112,21 +179,36 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         # Wait for body element to appear
         self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
 
-    def fill_select2_field(self, field_name, value):
+    def _fill_select2_field(self, field_name, value, search_box_class=None):
         """
         Helper function to fill a Select2 single selection field.
         """
+        if search_box_class is None:
+            search_box_class = "select2-search select2-search--dropdown"
+
         self.browser.find_by_xpath(f"//select[@id='id_{field_name}']//following-sibling::span").click()
-        search_box = self.browser.find_by_xpath(
-            "//*[@class='select2-search select2-search--dropdown']//input", wait_time=5
-        )
+        search_box = self.browser.find_by_xpath(f"//*[@class='{search_box_class}']//input", wait_time=5)
         for _ in search_box.first.type(value, slowly=True):
             pass
 
         # wait for "searching" to disappear
         self.browser.is_element_not_present_by_css(".loading-results", wait_time=5)
+        return search_box
+
+    def fill_select2_field(self, field_name, value):
+        """
+        Helper function to fill a Select2 single selection field on add/edit forms.
+        """
+        search_box = self._fill_select2_field(field_name, value)
         search_box.first.type(Keys.ENTER)
 
+    def fill_filters_select2_field(self, field_name, value):
+        """
+        Helper function to fill a Select2 single selection field on filters modals.
+        """
+        self._fill_select2_field(field_name, value, search_box_class="select2-search select2-search--inline")
+        self.browser.find_by_xpath(f"//li[@class='select2-results__option' and text()='{value}']").click()
+
     def fill_select2_multiselect_field(self, field_name, value):
         """
         Helper function to fill a Select2 multi-selection field.