nautobot 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

nautobot/extras/plugins/__init__.py

@@ -31,7 +31,6 @@ logger = getLogger(__name__)
 registry["plugin_banners"] = []
 registry["plugin_custom_validators"] = collections.defaultdict(list)
 registry["plugin_graphql_types"] = []
-registry["plugin_jobs"] = []
 registry["plugin_template_extensions"] = collections.defaultdict(list)
 registry["app_metrics"] = []
 
@@ -141,9 +140,9 @@ class NautobotAppConfig(NautobotConfig):
             register_graphql_types(graphql_types)
 
         # Import jobs (if present)
+        # Note that we do *not* auto-call `register_jobs()` - the App is responsible for doing so when imported.
         jobs = import_object(f"{self.__module__}.{self.jobs}")
         if jobs is not None:
-            register_jobs(jobs)
             self.features["jobs"] = jobs
 
         # Import metrics (if present)
@@ -423,24 +422,6 @@ def register_graphql_types(class_list):
         registry["plugin_graphql_types"].append(item)
 
 
-def register_jobs(class_list):
-    """
-    Register a list of Job classes
-    """
-    from nautobot.extras.jobs import Job
-
-    for job in class_list:
-        if not inspect.isclass(job):
-            raise TypeError(f"Job class {job} was passed as an instance!")
-        if not issubclass(job, Job):
-            raise TypeError(f"{job} is not a subclass of extras.jobs.Job!")
-
-        registry["plugin_jobs"].append(job)
-
-    # Note that we do not (and cannot) update the Job records in the Nautobot database at this time.
-    # That is done in response to the `nautobot_database_ready` signal, see nautobot.extras.signals.refresh_job_models
-
-
 def register_metrics(function_list):
     """
     Register a list of metric functions

nautobot/extras/signals.py

@@ -21,7 +21,7 @@ from django.utils import timezone
 from django_prometheus.models import model_deletes, model_inserts, model_updates
 import redis.exceptions
 
-from nautobot.core.celery import app, import_jobs_as_celery_tasks
+from nautobot.core.celery import app, import_jobs
 from nautobot.core.models import BaseModel
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.logging import sanitize
@@ -103,7 +103,9 @@ def _handle_changed_object(sender, instance, raw=False, **kwargs):
     if raw:
         return
 
-    if change_context_state.get() is None:
+    change_context = change_context_state.get()
+
+    if change_context is None:
         return
 
     # Determine the type of change being made
@@ -119,36 +121,49 @@ def _handle_changed_object(sender, instance, raw=False, **kwargs):
 
     # Record an ObjectChange if applicable
     if hasattr(instance, "to_objectchange"):
-        user = change_context_state.get().get_user(instance)
+        user = change_context.get_user(instance)
         # save a copy of this instance's field cache so it can be restored after serialization
         # to prevent unexpected behavior when chaining multiple signal handlers
         original_cache = instance._state.fields_cache.copy()
 
+        changed_object_type = ContentType.objects.get_for_model(instance)
+        changed_object_id = instance.id
+
+        # Generate a unique identifier for this change to stash in the change context
+        # This is used for deferred change logging and for looking up related changes without querying the database
+        unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
+
         # If a change already exists for this change_id, user, and object, update it instead of creating a new one.
         # If the object was deleted then recreated with the same pk (don't do this), change the action to update.
-        related_changes = ObjectChange.objects.filter(
-            changed_object_type=ContentType.objects.get_for_model(instance),
-            changed_object_id=instance.pk,
-            user=user,
-            request_id=change_context_state.get().change_id,
-        )
-        objectchange = instance.to_objectchange(action)
-        if related_changes.exists():
-            most_recent_change = related_changes.order_by("-time").first()
-            if most_recent_change.action == ObjectChangeActionChoices.ACTION_DELETE:
-                most_recent_change.action = ObjectChangeActionChoices.ACTION_UPDATE
-            most_recent_change.object_data = objectchange.object_data
-            most_recent_change.object_data_v2 = objectchange.object_data_v2
-            most_recent_change.save()
-            objectchange = most_recent_change
+        if unique_object_change_id in change_context.deferred_object_changes:
+            related_changes = ObjectChange.objects.filter(
+                changed_object_type=changed_object_type,
+                changed_object_id=changed_object_id,
+                user=user,
+                request_id=change_context.change_id,
+            )
+
+            # Skip the database check when deferring object changes
+            if not change_context.defer_object_changes and related_changes.exists():
+                objectchange = instance.to_objectchange(action)
+                most_recent_change = related_changes.order_by("-time").first()
+                if most_recent_change.action == ObjectChangeActionChoices.ACTION_DELETE:
+                    most_recent_change.action = ObjectChangeActionChoices.ACTION_UPDATE
+                most_recent_change.object_data = objectchange.object_data
+                most_recent_change.object_data_v2 = objectchange.object_data_v2
+                most_recent_change.save()
+
         else:
-            objectchange.user = user
-            objectchange.request_id = change_context_state.get().change_id
-            objectchange.change_context = change_context_state.get().context
-            objectchange.change_context_detail = change_context_state.get().context_detail[
-                :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
+            change_context.deferred_object_changes[unique_object_change_id] = [
+                {"action": action, "instance": instance, "user": user}
             ]
-            objectchange.save()
+            if not change_context.defer_object_changes:
+                objectchange = instance.to_objectchange(action)
+                objectchange.user = user
+                objectchange.request_id = change_context.change_id
+                objectchange.change_context = change_context.context
+                objectchange.change_context_detail = change_context.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                objectchange.save()
 
         # restore field cache
         instance._state.fields_cache = original_cache
@@ -171,7 +186,9 @@ def _handle_deleted_object(sender, instance, **kwargs):
     """
     Fires when an object is deleted.
     """
-    if change_context_state.get() is None:
+    change_context = change_context_state.get()
+
+    if change_context is None:
         return
 
     if isinstance(instance, BaseModel):
@@ -186,41 +203,58 @@ def _handle_deleted_object(sender, instance, **kwargs):
 
     # Record an ObjectChange if applicable
     if hasattr(instance, "to_objectchange"):
-        user = change_context_state.get().get_user(instance)
+        user = change_context.get_user(instance)
 
         # save a copy of this instance's field cache so it can be restored after serialization
         # to prevent unexpected behavior when chaining multiple signal handlers
         original_cache = instance._state.fields_cache.copy()
 
+        changed_object_type = ContentType.objects.get_for_model(instance)
+        changed_object_id = instance.id
+
+        # Generate a unique identifier for this change to stash in the change context
+        # This is used for deferred change logging and for looking up related changes without querying the database
+        unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
+        save_new_objectchange = True
+
         # if a change already exists for this change_id, user, and object, update it instead of creating a new one
         # except in the case that the object was created and deleted in the same change_id
         # we don't want to create a delete change for an object that never existed
-        related_changes = ObjectChange.objects.filter(
-            changed_object_type=ContentType.objects.get_for_model(instance),
-            changed_object_id=instance.pk,
-            user=user,
-            request_id=change_context_state.get().change_id,
-        )
-        objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
-        save_new_objectchange = True
-        if related_changes.exists():
-            most_recent_change = related_changes.order_by("-time").first()
-            if most_recent_change.action != ObjectChangeActionChoices.ACTION_CREATE:
-                most_recent_change.action = ObjectChangeActionChoices.ACTION_DELETE
-                most_recent_change.object_data = objectchange.object_data
-                most_recent_change.object_data_v2 = objectchange.object_data_v2
-                most_recent_change.save()
-                objectchange = most_recent_change
+        if unique_object_change_id in change_context.deferred_object_changes:
+            cached_related_change = change_context.deferred_object_changes[unique_object_change_id][-1]
+            if cached_related_change["action"] != ObjectChangeActionChoices.ACTION_CREATE:
+                cached_related_change["action"] = ObjectChangeActionChoices.ACTION_DELETE
                 save_new_objectchange = False
 
+            related_changes = ObjectChange.objects.filter(
+                changed_object_type=changed_object_type,
+                changed_object_id=changed_object_id,
+                user=user,
+                request_id=change_context.change_id,
+            )
+
+            # Skip the database check when deferring object changes
+            if not change_context.defer_object_changes and related_changes.exists():
+                objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                most_recent_change = related_changes.order_by("-time").first()
+                if most_recent_change.action != ObjectChangeActionChoices.ACTION_CREATE:
+                    most_recent_change.action = ObjectChangeActionChoices.ACTION_DELETE
+                    most_recent_change.object_data = objectchange.object_data
+                    most_recent_change.object_data_v2 = objectchange.object_data_v2
+                    most_recent_change.save()
+                    save_new_objectchange = False
+
         if save_new_objectchange:
-            objectchange.user = user
-            objectchange.request_id = change_context_state.get().change_id
-            objectchange.change_context = change_context_state.get().context
-            objectchange.change_context_detail = change_context_state.get().context_detail[
-                :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
-            ]
-            objectchange.save()
+            change_context.deferred_object_changes.setdefault(unique_object_change_id, []).append(
+                {"action": ObjectChangeActionChoices.ACTION_DELETE, "instance": instance, "user": user}
+            )
+            if not change_context.defer_object_changes:
+                objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                objectchange.user = user
+                objectchange.request_id = change_context.change_id
+                objectchange.change_context = change_context.context
+                objectchange.change_context_detail = change_context.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                objectchange.save()
 
         # restore field cache
         instance._state.fields_cache = original_cache
@@ -299,7 +333,7 @@ def git_repository_pre_delete(instance, **kwargs):
         app.control.broadcast("discard_git_repository", repository_slug=instance.slug)
         # But we don't have an equivalent way to broadcast to any other Django instances.
         # For now we just delete the one that we have locally and rely on other methods,
-        # such as the import_jobs_as_celery_tasks() signal that runs on server startup,
+        # such as the import_jobs() signal that runs on server startup,
         # to clean up other clones as they're encountered.
         if os.path.isdir(instance.filesystem_path):
             shutil.rmtree(instance.filesystem_path)
@@ -428,7 +462,7 @@ def refresh_job_models(sender, *, apps, **kwargs):
     """
     Callback for the nautobot_database_ready signal; updates Jobs in the database based on Job source file availability.
     """
-    from nautobot.extras.jobs import Job as JobClass  # avoid circular import
+    from nautobot.extras.jobs import get_jobs  # avoid circular import
 
     Job = apps.get_model("extras", "Job")
 
@@ -437,15 +471,12 @@ def refresh_job_models(sender, *, apps, **kwargs):
         logger.info("Skipping refresh_job_models() as it appears Job model has not yet been migrated to latest.")
         return
 
-    import_jobs_as_celery_tasks(app)
+    import_jobs()
 
     job_models = []
-    for task in app.tasks.values():
-        # Skip Celery tasks that aren't Jobs
-        if not isinstance(task, JobClass):
-            continue
 
-        job_model, _ = refresh_job_model_from_job_class(Job, task.__class__)
+    for job_class in get_jobs().values():
+        job_model, _ = refresh_job_model_from_job_class(Job, job_class)
         if job_model is not None:
             job_models.append(job_model)
 

nautobot/extras/test_jobs/__init__.py

@@ -0,0 +1,8 @@
+def load_tests(*args):
+    """Implement unittest discovery for this submodule as a no-op.
+
+    This prevents unittest from recursively loading all of the modules under this directory to inspect whether they
+    define test cases. This is necessary because otherwise the `jobs_module` submodule will get loaded when tests run,
+    which will in turn call `register_jobs()`, incorrectly/unexpectedly registering the test Job defined in that module
+    as if it were a system Job, which will cause tests to fail due to the unexpected presence of this Job.
+    """

nautobot/extras/test_jobs/dry_run.py

@@ -1,5 +1,5 @@
 from nautobot.core.celery import register_jobs
-from nautobot.extras.jobs import DryRunVar, get_task_logger, Job
+from nautobot.extras.jobs import DryRunVar, get_task_logger, IntegerVar, Job
 from nautobot.extras.models import Status
 
 logger = get_task_logger(__name__)
@@ -11,8 +11,9 @@ class TestDryRun(Job):
     """
 
     dryrun = DryRunVar()
+    value = IntegerVar(required=False)
 
-    def run(self, dryrun):
+    def run(self, dryrun, value=None):
         """
         Job function.
         """

nautobot/extras/test_jobs/fail.py

@@ -1,4 +1,7 @@
+from billiard.einfo import ExceptionInfo
+
 from nautobot.core.celery import register_jobs
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.extras.jobs import get_task_logger, Job, RunJobTaskFailed
 
 logger = get_task_logger(__name__)
@@ -11,6 +14,15 @@ class TestFail(Job):
 
     description = "Validate job import"
 
+    def before_start(self, task_id, args, kwargs):
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        logger.info("before_start() was called as expected")
+
     def run(self):
         """
         Job function.
@@ -18,6 +30,37 @@ class TestFail(Job):
         logger.info("I'm a test job that fails!")
         raise RunJobTaskFailed("Test failure")
 
+    def on_success(self, retval, task_id, args, kwargs):
+        raise RuntimeError("on_success() was unexpectedly called!")
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        if not isinstance(exc, RunJobTaskFailed):
+            raise RuntimeError(f"Expected exc to be a RunJobTaskFailed, but it was {exc!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if not isinstance(einfo, ExceptionInfo):
+            raise RuntimeError(f"Expected einfo to be an ExceptionInfo, but it was {einfo!r}")
+        logger.info("on_failure() was called as expected")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if status is not JobResultStatusChoices.STATUS_FAILURE:
+            raise RuntimeError(f"Expected status to be {JobResultStatusChoices.STATUS_FAILURE}, but it was {status!r}")
+        if not isinstance(retval, RunJobTaskFailed):
+            raise RuntimeError(f"Expected retval to be a RunJobTaskFailed, but it was {retval!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if not isinstance(einfo, ExceptionInfo):
+            raise RuntimeError(f"Expected einfo to be an ExceptionInfo, but it was {einfo!r}")
+        logger.info("after_return() was called as expected")
+
 
 class TestFailWithSanitization(Job):
     """

nautobot/extras/test_jobs/ipaddress_vars.py

@@ -1,5 +1,7 @@
 import json
 
+import netaddr
+
 from nautobot.core.celery import register_jobs
 from nautobot.extras.jobs import get_task_logger, IPAddressVar, IPAddressWithMaskVar, Job
 
@@ -30,7 +32,26 @@ class TestIPAddresses(Job):
         description="IPv6 network",
     )
 
-    def run(self, ipv4_address, ipv4_with_mask, ipv4_network, ipv6_address, ipv6_with_mask, ipv6_network):
+    def before_start(self, task_id, args, kwargs):
+        for expected_kwarg in self._get_vars().keys():
+            if expected_kwarg not in kwargs:
+                raise RuntimeError(f"kwargs should contain {expected_kwarg} but it doesn't!")
+            if kwargs[expected_kwarg] is None:
+                raise RuntimeError(f"kwargs[{expected_kwarg}] is unexpectedly None!")
+
+    def run(self, *, ipv4_address, ipv4_with_mask, ipv4_network, ipv6_address, ipv6_with_mask, ipv6_network):
+        if not isinstance(ipv4_address, netaddr.IPAddress):
+            raise RuntimeError(f"Expected ipv4_address to be a netaddr.IPAddress, but it was {ipv4_address!r}")
+        if not isinstance(ipv4_with_mask, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv4_with_mask to be a netaddr.IPNetwork, but it was {ipv4_with_mask!r}")
+        if not isinstance(ipv4_network, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv4_network to be a netaddr.IPNetwork, but it was {ipv4_network!r}")
+        if not isinstance(ipv6_address, netaddr.IPAddress):
+            raise RuntimeError(f"Expected ipv6_address to be a netaddr.IPAddress, but it was {ipv6_address!r}")
+        if not isinstance(ipv6_with_mask, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv6_with_mask to be a netaddr.IPNetwork, but it was {ipv6_with_mask!r}")
+        if not isinstance(ipv6_network, netaddr.IPNetwork):
+            raise RuntimeError(f"Expected ipv6_network to be a netaddr.IPNetwork, but it was {ipv6_network!r}")
         # Log the data as JSON so we can pull it back out for testing.
         logger.info(
             "IP Address Test",
@@ -59,5 +80,23 @@ class TestIPAddresses(Job):
 
         return "Nice IPs, bro."
 
+    def on_success(self, retval, task_id, args, kwargs):
+        if retval != "Nice IPs, bro.":
+            raise RuntimeError(f"retval is unexpected: {retval!r}")
+        for expected_kwarg in self._get_vars().keys():
+            if expected_kwarg not in kwargs:
+                raise RuntimeError(f"kwargs should contain {expected_kwarg} but it doesn't!")
+            if kwargs[expected_kwarg] is None:
+                raise RuntimeError(f"kwargs[{expected_kwarg}] is unexpectedly None!")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if retval != "Nice IPs, bro.":
+            raise RuntimeError(f"retval is unexpected: {retval!r}")
+        for expected_kwarg in self._get_vars().keys():
+            if expected_kwarg not in kwargs:
+                raise RuntimeError(f"kwargs should contain {expected_kwarg} but it doesn't!")
+            if kwargs[expected_kwarg] is None:
+                raise RuntimeError(f"kwargs[{expected_kwarg}] is unexpectedly None!")
+
 
 register_jobs(TestIPAddresses)

nautobot/extras/test_jobs/jobs_module/__init__.py

@@ -0,0 +1,5 @@
+from nautobot.apps.jobs import register_jobs
+
+from .jobs_submodule import ChildJob
+
+register_jobs(ChildJob)

nautobot/extras/test_jobs/jobs_module/jobs_submodule/__init__.py

@@ -0,0 +1 @@
+from .jobs import ChildJob  # noqa: F401

nautobot/extras/test_jobs/jobs_module/jobs_submodule/jobs.py

@@ -0,0 +1,6 @@
+from nautobot.apps.jobs import Job
+
+
+class ChildJob(Job):
+    def run(self):
+        pass

nautobot/extras/test_jobs/pass.py

@@ -1,4 +1,5 @@
 from nautobot.core.celery import register_jobs
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.extras.jobs import get_task_logger, Job
 
 logger = get_task_logger(__name__)
@@ -14,11 +15,50 @@ class TestPass(Job):
     class Meta:
         has_sensitive_variables = False
 
+    def before_start(self, task_id, args, kwargs):
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        logger.info("before_start() was called as expected")
+
     def run(self):
         """
         Job function.
         """
         logger.info("Success")
+        return True
+
+    def on_success(self, retval, task_id, args, kwargs):
+        if retval is not True:
+            raise RuntimeError(f"Expected retval to be True, but it was {retval!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        logger.info("on_success() was called as expected")
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        raise RuntimeError("on_failure() was unexpectedly called!")
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        if status is not JobResultStatusChoices.STATUS_SUCCESS:
+            raise RuntimeError(f"Expected status to be {JobResultStatusChoices.STATUS_SUCCESS}, but it was {status!r}")
+        if retval is not True:
+            raise RuntimeError(f"Expected retval to be True, but it was {retval!r}")
+        if task_id != self.request.id:
+            raise RuntimeError(f"Expected task_id {task_id} to equal self.request.id {self.request.id}")
+        if args:
+            raise RuntimeError(f"Expected args to be empty, but it was {args!r}")
+        if kwargs:
+            raise RuntimeError(f"Expected kwargs to be empty, but it was {kwargs!r}")
+        if einfo is not None:
+            raise RuntimeError(f"Expected einfo to be None, but it was {einfo!r}")
+        logger.info("after_return() was called as expected")
 
 
 register_jobs(TestPass)

nautobot/extras/test_jobs/relative_import.py

@@ -0,0 +1,11 @@
+from fail import TestFail  # pylint: disable=import-error
+
+from nautobot.apps.jobs import register_jobs
+
+
+class TestReallyPass(TestFail):
+    def run(self):
+        pass
+
+
+register_jobs(TestReallyPass)

nautobot/extras/tests/test_api.py

@@ -2303,6 +2303,7 @@ class JobApprovalTest(APITestCase):
             name="test dryrun",
             task="dry_run.TestDryRun",
             job_model=cls.dryrun_job_model,
+            kwargs={"value": 1},
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=cls.additional_user,
             approval_required=True,
@@ -2442,6 +2443,8 @@ class JobApprovalTest(APITestCase):
         url = reverse("extras-api:scheduledjob-dry-run", kwargs={"pk": self.dryrun_scheduled_job.pk})
         response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
+        # The below fails because JobResult.task_kwargs doesn't get set until *after* the task begins executing.
+        # self.assertEqual(response.data["task_kwargs"], {"dryrun": True, "value": 1}, response.data)
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_dry_run_not_supported(self):

nautobot/extras/tests/test_context_managers.py

@@ -7,7 +7,10 @@ from nautobot.core.testing import TransactionTestCase
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.models import Location, LocationType
 from nautobot.extras.choices import ObjectChangeActionChoices, ObjectChangeEventContextChoices
-from nautobot.extras.context_managers import web_request_context
+from nautobot.extras.context_managers import (
+    deferred_change_logging_for_bulk_operation,
+    web_request_context,
+)
 from nautobot.extras.models import Status, Webhook
 
 # Use the proper swappable User model
@@ -193,3 +196,97 @@ class WebRequestContextTransactionTestCase(TransactionTestCase):
             Status.objects.create(name="Test Status 2")
 
         self.assertEqual(get_changes_for_model(Status).count(), 2)
+
+
+class BulkEditDeleteChangeLogging(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username="jacob",
+            email="jacob@example.com",
+            password="top_secret",  # noqa: S106  # hardcoded-password-func-arg -- ok as this is test code only
+        )
+
+    def test_change_log_created(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+
+        location = Location.objects.get(name="Test Location 1")
+        oc_list = get_changes_for_model(location).order_by("pk")
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].changed_object, location)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+
+    def test_delete(self):
+        """Test that deletes raise an exception"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with self.assertRaises(ValueError):
+            with web_request_context(self.user):
+                with deferred_change_logging_for_bulk_operation():
+                    location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                    location.save()
+                    location.delete()
+
+    def test_create_then_update(self):
+        """Test that a create followed by an update is logged as a single create"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+                location.description = "changed"
+                location.save()
+
+        oc_list = get_changes_for_model(location)
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+        snapshots = oc_list[0].get_snapshots()
+        self.assertIsNone(snapshots["prechange"])
+        self.assertIsNotNone(snapshots["postchange"])
+        self.assertIsNone(snapshots["differences"]["removed"])
+        self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_bulk_edit(self):
+        """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()
+        locations = [
+            Location(name=f"Test Location {i}", location_type=location_type, status=location_status)
+            for i in range(1, 4)
+        ]
+        Location.objects.bulk_create(locations)
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                for location in locations:
+                    location.description = "changed"
+                    location.save()
+
+        oc_list = get_changes_for_model(Location)
+        self.assertEqual(len(oc_list), 3)
+        for oc in oc_list:
+            self.assertEqual(oc.action, ObjectChangeActionChoices.ACTION_UPDATE)
+            snapshots = oc.get_snapshots()
+            self.assertIsNone(snapshots["prechange"])
+            self.assertIsNotNone(snapshots["postchange"])
+            self.assertIsNone(snapshots["differences"]["removed"])
+            self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_change_log_context(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user, context_detail="test_change_log_context"):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+
+        location = Location.objects.get(name="Test Location 1")
+        oc_list = get_changes_for_model(location)
+        with self.subTest():
+            self.assertEqual(oc_list[0].change_context, ObjectChangeEventContextChoices.CONTEXT_ORM)
+        with self.subTest():
+            self.assertEqual(oc_list[0].change_context_detail, "test_change_log_context")