nautobot 2.3.8__py3-none-any.whl → 2.3.10__py3-none-any.whl

nautobot/extras/plugins/__init__.py

@@ -94,6 +94,7 @@ class NautobotAppConfig(NautobotConfig):
     metrics = "metrics.metrics"
     menu_items = "navigation.menu_items"
     secrets_providers = "secrets.secrets_providers"
+    table_extensions = "table_extensions.table_extensions"
     template_extensions = "template_content.template_extensions"
     override_views = "views.override_views"
 
@@ -211,6 +212,9 @@ class NautobotAppConfig(NautobotConfig):
                 )
             register_override_views(override_views, self.name)
 
+        # Register tables extensions (if any).
+        self._register_table_extensions()
+
     @classmethod
     def validate(cls, user_config, nautobot_version):
         """Validate the user_config for baseline correctness."""
@@ -262,6 +266,13 @@ class NautobotAppConfig(NautobotConfig):
             if setting not in user_config and setting not in cls.constance_config:
                 user_config[setting] = value
 
+    def _register_table_extensions(self):
+        """Register tables extensions (if any)."""
+        table_extensions = import_object(f"{self.__module__}.{self.table_extensions}")
+        if table_extensions is not None:
+            register_table_extensions(table_extensions, self.name)
+            self.features["table_extensions"] = get_table_extension_features(table_extensions)
+
 
 @class_deprecated_in_favor_of(NautobotAppConfig)
 class PluginConfig(NautobotAppConfig):
@@ -491,6 +502,160 @@ def register_filter_extensions(filter_extensions, plugin_name):
                 )
 
 
+#
+# Table Extensions
+#
+
+
+class TableExtension:
+    """Template class for extending Tables.
+
+    An app can override the default columns for a table by either:
+    - Extending the original default columns to include custom columns.
+        - add_to_default_columns = ("my_app_name_new_column",)
+    - Removing native columns from the default columns.
+        - remove_from_default_columns = ("tenant",)
+    """
+
+    model = None
+    table_columns = {}
+    add_to_default_columns = ()
+    remove_from_default_columns = ()
+
+    @classmethod
+    def alter_queryset(cls, queryset):
+        """Alter the View class QuerySet.
+
+        This is a good place to add `prefetch_related` to the view queryset.
+        example:
+            return queryset.prefetch_related("my_model_set")
+        """
+        return queryset
+
+    @classmethod
+    def _get_table_columns_registrations(cls):
+        """Return a list of register labels fro each column."""
+        if not cls.table_columns:
+            return []
+        return [f"{cls.model} -> {column_name}" for column_name in cls.table_columns]
+
+    @classmethod
+    def _get_add_to_default_columns_registrations(cls):
+        """Return a list of register labels for each column added to defaults."""
+        if not cls.add_to_default_columns:
+            return []
+        return [f"{cls.model} -> {cls.add_to_default_columns}"]
+
+    @classmethod
+    def _get_remove_from_default_columns_registrations(cls):
+        """Return a list of register labels for each column removed from defaults."""
+        if not cls.remove_from_default_columns:
+            return []
+        return [f"{cls.model} -> {cls.remove_from_default_columns}"]
+
+
+def get_table_extension_features(table_extensions):
+    """Return a dictionary of TableExtension features for the App detail view."""
+    return {
+        "columns": [
+            label
+            for table_extension in table_extensions
+            for label in table_extension._get_table_columns_registrations()
+        ],
+        "add_to_default_columns": [
+            label
+            for table_extension in table_extensions
+            for label in table_extension._get_add_to_default_columns_registrations()
+        ],
+        "remove_from_default_columns": [
+            label
+            for table_extension in table_extensions
+            for label in table_extension._get_remove_from_default_columns_registrations()
+        ],
+    }
+
+
+def register_table_extensions(table_extensions, app_name):
+    """Register a list of TableExtension classes."""
+    for table_extension in table_extensions:
+        _validate_is_subclass_of_table_extension(table_extension)
+        _add_columns_into_model_table(table_extension, app_name)
+        _modify_default_table_columns(table_extension, app_name)
+        _alter_table_view_queryset(table_extension, app_name)
+
+
+def _add_columns_into_model_table(table_extension, app_name):
+    """Inject each new column into the Model Table."""
+    from nautobot.core.utils.lookup import get_table_for_model
+
+    if not isinstance(table_extension.table_columns, dict):
+        error = f"{app_name} TableExtension: 'table_columns' attribute must be of type 'dict'."
+        logger.error(error)
+        return
+
+    table = get_table_for_model(table_extension.model)
+    for name, column in table_extension.table_columns.items():
+        _validate_table_column_name_is_prefixed_with_app_name(name, app_name)
+        _add_column_to_table_base_columns(table, name, column, app_name)
+
+
+def _add_column_to_table_base_columns(table, column_name, column, app_name):
+    """Attach a column to an existing table."""
+    import django_tables2
+
+    if not isinstance(column, django_tables2.Column):
+        raise TypeError(f"Custom column `{column_name}` is not an instance of django_tables2.Column.")
+
+    if column_name in table.base_columns:
+        logger.error(
+            f"{app_name}: There was a name conflict with existing table column `{column_name}`, the custom column was ignored."
+        )
+    else:
+        table.base_columns[column_name] = column
+
+
+def _alter_table_view_queryset(table_extension, app_name):
+    """Replace the model view queryset with an optimized queryset from the app."""
+    from nautobot.core.utils.lookup import get_view_for_model
+
+    # TODO: Investigate if there is a more targeted way to patch only the list view queryset
+    # when targeting a subclass of `NautobotUIViewSet`.
+    view = get_view_for_model(table_extension.model, view_type="List")
+    view.queryset = table_extension.alter_queryset(view.queryset)
+
+
+def _modify_default_table_columns(table_extension, app_name):
+    """Add or remove columns from the table default columns."""
+    from nautobot.core.utils.lookup import get_table_for_model
+
+    table = get_table_for_model(table_extension.model)
+    message = (
+        f"{app_name}: Cannot {{action}} column `{{column_name}}` {{preposition}} the default columns for `{table}`."
+    )
+
+    for column_name in table_extension.add_to_default_columns:
+        if column_name in table.base_columns:
+            table.Meta.default_columns = (*table.Meta.default_columns, column_name)
+        else:
+            logger.debug(message.format(action="add", column_name=column_name, preposition="to"))
+
+    for column_name in table_extension.remove_from_default_columns:
+        if column_name in table.Meta.default_columns:
+            table.Meta.default_columns = tuple(name for name in table.Meta.default_columns if name != column_name)
+        else:
+            logger.debug(message.format(action="remove", column_name=column_name, preposition="from"))
+
+
+def _validate_is_subclass_of_table_extension(table_extension):
+    if not issubclass(table_extension, TableExtension):
+        raise TypeError(f"{table_extension} is not a subclass of nautobot.apps.filters.TableExtension!")
+
+
+def _validate_table_column_name_is_prefixed_with_app_name(name, app_name):
+    if not name.startswith(f"{app_name}_"):
+        raise ValueError(f"Attempted to create a custom table column `{name}` that did not start with `{app_name}`")
+
+
 #
 # Navigation menu links
 #

nautobot/extras/signals.py

@@ -91,6 +91,8 @@ def invalidate_models_cache(sender, **kwargs):
     with contextlib.suppress(redis.exceptions.ConnectionError):
         # TODO: *maybe* target more narrowly, e.g. only clear the cache for specific related content-types?
         cache.delete_pattern(f"{manager.get_for_model.cache_key_prefix}.*")
+        if hasattr(manager, "keys_for_model"):
+            cache.delete_pattern(f"{manager.keys_for_model.cache_key_prefix}.*")
 
 
 @receiver(post_save, sender=Relationship)

nautobot/extras/tasks.py

@@ -2,18 +2,42 @@ from logging import getLogger
 
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.db import transaction
 from jinja2.exceptions import TemplateError
 import requests
 
 from nautobot.core.celery import nautobot_task
+from nautobot.core.models.query_functions import JSONRemove, JSONSet
 from nautobot.extras.choices import CustomFieldTypeChoices, ObjectChangeActionChoices
 from nautobot.extras.utils import generate_signature
 
 logger = getLogger("nautobot.extras.tasks")
 
 
-@nautobot_task
+def _generate_bulk_object_changes(context, queryset, task_logger):
+    # Circular import
+    from nautobot.extras.context_managers import (
+        change_logging,
+        ChangeContext,
+        deferred_change_logging_for_bulk_operation,
+    )
+    from nautobot.extras.signals import _handle_changed_object
+
+    task_logger.info("Creating deferred ObjectChange records for bulk operation...")
+
+    # Note: we use change_logging() here instead of web_request_context() because we don't want these change records to
+    #       trigger jobhooks and webhooks.
+    # TODO: this could be made much faster if we ensure the queryset has appropriate select_related/prefetch_related?
+    change_context = ChangeContext(**context)
+    i = 0
+    with change_logging(change_context):
+        with deferred_change_logging_for_bulk_operation():
+            for i, instance in enumerate(queryset.iterator(), start=1):
+                _handle_changed_object(queryset.model, instance, created=False)
+
+    task_logger.info("Created %d ObjectChange records", i)
+
+
+@nautobot_task(soft_time_limit=1800, time_limit=2000)
 def update_custom_field_choice_data(field_id, old_value, new_value, change_context=None):
     """
     Update the values for a custom field choice used in objects' _custom_field_data for the given field.
@@ -22,47 +46,48 @@ def update_custom_field_choice_data(field_id, old_value, new_value, change_conte
         field_id (uuid4): The PK of the custom field to which this choice value relates
         old_value (str): The existing value of the choice
         new_value (str): The value which will be used as replacement
+        change_context (dict): Optional dict representation of change context for ObjectChange creation
     """
     # Circular Import
     from nautobot.extras.context_managers import web_request_context
     from nautobot.extras.models import CustomField
 
+    task_logger = getLogger("celery.task.update_custom_field_choice_data")
+
     try:
         field = CustomField.objects.get(pk=field_id)
     except CustomField.DoesNotExist:
-        logger.error(f"Custom field with ID {field_id} not found, failing to act on choice data.")
-        return False
+        task_logger.error("Custom field with ID %s not found, failing to act on choice data.", field_id)
+        raise
 
     if field.type == CustomFieldTypeChoices.TYPE_SELECT:
         # Loop through all field content types and search for values to update
         for ct in field.content_types.all():
             model = ct.model_class()
+            queryset = model.objects.filter(**{f"_custom_field_data__{field.key}": old_value})
             if change_context is not None:
-                with web_request_context(
-                    user=change_context.get("user"),
-                    change_id=change_context.get("change_id"),
-                    context_detail=change_context.get("context_detail"),
-                    context=change_context.get("context"),
-                ):
-                    for obj in model.objects.filter(**{f"_custom_field_data__{field.key}": old_value}):
-                        obj._custom_field_data[field.key] = new_value
-                        obj.save()
-            else:
-                for obj in model.objects.filter(**{f"_custom_field_data__{field.key}": old_value}):
-                    obj._custom_field_data[field.key] = new_value
-                    obj.save()
+                pk_list = list(queryset.values_list("pk", flat=True))
+            task_logger.info(
+                "Updating selection for custom field `%s` from `%s` to `%s` on %s records...",
+                field.key,
+                old_value,
+                new_value,
+                ct.model,
+                extra={"object": field},
+            )
+            count = queryset.update(_custom_field_data=JSONSet("_custom_field_data", field.key, new_value))
+            task_logger.info("Updated %d records", count)
+            if change_context is not None:
+                # Since we used update() above, we bypassed ObjectChange automatic creation via signals. Create them now
+                _generate_bulk_object_changes(change_context, model.objects.filter(pk__in=pk_list), task_logger)
 
     elif field.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
         # Loop through all field content types and search for values to update
+        # TODO: can we implement a bulk operator for this?
         for ct in field.content_types.all():
             model = ct.model_class()
             if change_context is not None:
-                with web_request_context(
-                    user=change_context.get("user"),
-                    change_id=change_context.get("change_id"),
-                    context_detail=change_context.get("context_detail"),
-                    context=change_context.get("context"),
-                ):
+                with web_request_context(**change_context):
                     for obj in model.objects.filter(**{f"_custom_field_data__{field.key}__contains": old_value}):
                         old_list = obj._custom_field_data[field.key]
                         new_list = [new_value if e == old_value else e for e in old_list]
@@ -76,13 +101,13 @@ def update_custom_field_choice_data(field_id, old_value, new_value, change_conte
                     obj.save()
 
     else:
-        logger.error(f"Unknown field type, failing to act on choice data for this field {field.key}.")
-        return False
+        task_logger.error(f"Unknown field type, failing to act on choice data for this field {field.key}.")
+        raise ValueError
 
     return True
 
 
-@nautobot_task
+@nautobot_task(soft_time_limit=1800, time_limit=2000)
 def delete_custom_field_data(field_key, content_type_pk_set, change_context=None):
     """
     Delete the values for a custom field
@@ -90,30 +115,23 @@ def delete_custom_field_data(field_key, content_type_pk_set, change_context=None
     Args:
         field_key (str): The key of the custom field which is being deleted
         content_type_pk_set (list): List of PKs for content types to act upon
+        change_context (dict): Optional change context for ObjectChange creation
     """
-    # Circular Import
-    from nautobot.extras.context_managers import web_request_context
-
-    with transaction.atomic():
-        for ct in ContentType.objects.filter(pk__in=content_type_pk_set):
-            model = ct.model_class()
-            if change_context is not None:
-                with web_request_context(
-                    user=change_context.get("user"),
-                    change_id=change_context.get("change_id"),
-                    context_detail=change_context.get("context_detail"),
-                    context=change_context.get("context"),
-                ):
-                    for obj in model.objects.filter(**{f"_custom_field_data__{field_key}__isnull": False}):
-                        del obj._custom_field_data[field_key]
-                        obj.save()
-            else:
-                for obj in model.objects.filter(**{f"_custom_field_data__{field_key}__isnull": False}):
-                    del obj._custom_field_data[field_key]
-                    obj.save()
-
-
-@nautobot_task
+    task_logger = getLogger("celery.task.delete_custom_field_data")
+    for ct in ContentType.objects.filter(pk__in=content_type_pk_set):
+        model = ct.model_class()
+        queryset = model.objects.filter(**{f"_custom_field_data__{field_key}__isnull": False})
+        if change_context is not None:
+            pk_list = list(queryset.values_list("pk", flat=True))
+        task_logger.info("Deleting existing values for custom field `%s` from %s records...", field_key, ct.model)
+        count = queryset.update(_custom_field_data=JSONRemove("_custom_field_data", field_key))
+        task_logger.info("Updated %d records", count)
+        if change_context is not None:
+            # Since we used update() above, we bypassed ObjectChange automatic creation via signals. Create them now
+            _generate_bulk_object_changes(change_context, model.objects.filter(pk__in=pk_list), task_logger)
+
+
+@nautobot_task(soft_time_limit=1800, time_limit=2000)
 def provision_field(field_id, content_type_pk_set, change_context=None):
     """
     Provision a new custom field on all relevant content type object instances.
@@ -121,34 +139,35 @@ def provision_field(field_id, content_type_pk_set, change_context=None):
     Args:
         field_id (uuid4): The PK of the custom field being provisioned
         content_type_pk_set (list): List of PKs for content types to act upon
+        change_context (dict): Optional change context for ObjectChange creation.
     """
     # Circular Import
-    from nautobot.extras.context_managers import web_request_context
     from nautobot.extras.models import CustomField
 
+    task_logger = getLogger("celery.task.provision_field")
+
     try:
         field = CustomField.objects.get(pk=field_id)
     except CustomField.DoesNotExist:
-        logger.error(f"Custom field with ID {field_id} not found, failing to provision.")
-        return False
+        task_logger.error(f"Custom field with ID {field_id} not found, failing to provision.")
+        raise
 
-    with transaction.atomic():
-        for ct in ContentType.objects.filter(pk__in=content_type_pk_set):
-            model = ct.model_class()
-            if change_context is not None:
-                with web_request_context(
-                    user=change_context.get("user"),
-                    change_id=change_context.get("change_id"),
-                    context_detail=change_context.get("context_detail"),
-                    context=change_context.get("context"),
-                ):
-                    for obj in model.objects.all():
-                        obj._custom_field_data.setdefault(field.key, field.default)
-                        obj.save()
-            else:
-                for obj in model.objects.all():
-                    obj._custom_field_data.setdefault(field.key, field.default)
-                    obj.save()
+    for ct in ContentType.objects.filter(pk__in=content_type_pk_set):
+        model = ct.model_class()
+        queryset = model.objects.filter(**{f"_custom_field_data__{field.key}__isnull": True})
+        if change_context is not None:
+            pk_list = list(queryset.values_list("pk", flat=True))
+        task_logger.info(
+            "Adding data for custom field `%s` to %s records...",
+            field.key,
+            ct.model,
+            extra={"object": field},
+        )
+        count = queryset.update(_custom_field_data=JSONSet("_custom_field_data", field.key, field.default))
+        task_logger.info("Updated %d records.", count)
+        if change_context is not None:
+            # Since we used update() above, we bypassed ObjectChange automatic creation via signals. Create them now
+            _generate_bulk_object_changes(change_context, model.objects.filter(pk__in=pk_list), task_logger)
 
     return True
 

nautobot/extras/templates/extras/plugin_detail.html

@@ -277,6 +277,39 @@
                                     {% endif %}
                                 </td>
                             </tr>
+                            <tr>
+                                <td>Table Extensions</td>
+                                <td>
+                                    {% if features.table_extensions %}
+                                        {% if features.table_extensions.columns %}
+                                        <b>Custom Columns</b>
+                                        <ul class="list-unstyled">
+                                            {% for column in features.table_extensions.columns %}
+                                                <li><code>{{ column }}</code></li>
+                                            {% endfor %}
+                                        </ul>
+                                        {% endif %}
+                                        {% if features.table_extensions.add_to_default_columns %}
+                                        <b>Additional Default Columns</b>
+                                        <ul class="list-unstyled">
+                                            {% for column in features.table_extensions.add_to_default_columns %}
+                                                <li><code>{{ column }}</code></li>
+                                            {% endfor %}
+                                        </ul>
+                                        {% endif %}
+                                        {% if features.table_extensions.remove_from_default_columns %}
+                                        <b>Remove from Default Columns</b>
+                                        <ul class="list-unstyled">
+                                            {% for column in features.table_extensions.remove_from_default_columns %}
+                                                <li><code>{{ column }}</code></li>
+                                            {% endfor %}
+                                        </ul>
+                                        {% endif %}
+                                    {% else %}
+                                        {% include 'utilities/render_boolean.html' with value=features.table_extensions %}
+                                    {% endif %}
+                                </td>
+                            </tr>
                             <tr>
                                 <td>Views/URLs</td>
                                 <td>

nautobot/extras/tests/test_context_managers.py

@@ -5,7 +5,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.test import TestCase
 
 from nautobot.core.celery import app
-from nautobot.core.testing import TransactionTestCase
+from nautobot.core.testing import get_job_class_and_model, TransactionTestCase
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.models import (
     DeviceType,
@@ -22,7 +22,7 @@ from nautobot.extras.context_managers import (
     deferred_change_logging_for_bulk_operation,
     web_request_context,
 )
-from nautobot.extras.models import Status, Webhook
+from nautobot.extras.models import JobHook, Status, Webhook
 from nautobot.extras.utils import bulk_delete_with_bulk_change_logging
 
 # Use the proper swappable User model
@@ -74,8 +74,8 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(oc_list[0].changed_object, location)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
 
-    @mock.patch("nautobot.extras.jobs.enqueue_job_hooks")
-    @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
+    @mock.patch("nautobot.extras.jobs.enqueue_job_hooks", return_value=(True, None))
+    @mock.patch("nautobot.extras.context_managers.enqueue_webhooks", return_value=None)
     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")
@@ -88,12 +88,19 @@ class WebRequestContextTestCase(TestCase):
 
         location = Location.objects.filter(pk=location_pk)
         self.assertFalse(location.exists())
-        oc_list = get_changes_for_model(Location).filter(changed_object_id=location_pk)
+        oc_list = get_changes_for_model(Location).filter(changed_object_id=location_pk).order_by("time")
         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])])
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+        self.assertEqual(oc_list[1].action, ObjectChangeActionChoices.ACTION_DELETE)
+        mock_enqueue_job_hooks.assert_has_calls(
+            [
+                mock.call(oc_list[0], may_reload_jobs=True, jobhook_queryset=None),
+                mock.call(oc_list[1], may_reload_jobs=False, jobhook_queryset=None),
+            ],
+        )
+        mock_enqueue_webhooks.assert_has_calls(
+            [mock.call(oc_list[0], webhook_queryset=None), mock.call(oc_list[1], webhook_queryset=None)]
+        )
 
     def test_update_then_delete(self):
         """Test that an update followed by a delete is logged as a single delete"""
@@ -307,6 +314,13 @@ class BulkEditDeleteChangeLogging(TestCase):
             for i in range(1, 4)
         ]
         Location.objects.bulk_create(locations)
+        # Create a JobHook that applies to Locations
+        _, job_model = get_job_class_and_model("job_hook_receiver", "TestJobHookReceiverLog")
+        mock_import_jobs.assert_called_once()
+        mock_import_jobs.reset_mock()
+        job_hook = JobHook.objects.create(name="JobHookTest", type_update=True, job=job_model)
+        job_hook.content_types.set([ContentType.objects.get_for_model(Location)])
+
         pk_list = []
         with web_request_context(self.user):
             with deferred_change_logging_for_bulk_operation():

nautobot/extras/tests/test_datasources.py

@@ -412,7 +412,7 @@ class GitTest(TransactionTestCase):
 
     def test_pull_git_repository_and_refresh_data_with_bad_data(self):
         """
-        The test_pull_git_repository_and_refresh_data job should gracefully handle bad data in the Git repository
+        The test_pull_git_repository_and_refresh_data job should gracefully handle bad data in the Git repository.
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
@@ -433,6 +433,18 @@ class GitTest(TransactionTestCase):
                     job_result.result,
                 )
 
+                # Due to transaction rollback on failure, the database should still/again match the pre-sync state, of
+                # no records owned by the repository.
+                self.assertFalse(ConfigContextSchema.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(ConfigContext.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(ExportTemplate.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(Job.objects.filter(module_name__startswith=f"{self.repo.slug}.").exists())
+                device = Device.objects.get(name=self.device.name)
+                self.assertIsNone(device.local_config_context_data)
+                self.assertIsNone(device.local_config_context_data_owner)
+                self.repo.refresh_from_db()
+                self.assertEqual(self.repo.current_head, "")
+
                 # Check for specific log messages
                 log_entries = JobLogEntry.objects.filter(job_result=job_result)
                 warning_logs = log_entries.filter(log_level=LogLevelChoices.LOG_WARNING)
@@ -592,6 +604,81 @@ class GitTest(TransactionTestCase):
 
                 self.assert_job_exists(installed=False)
 
+    def test_git_repository_sync_rollback(self):
+        """
+        Once a "known-good" sync state is achieved, resync to a new "bad" head commit should fail and be rolled back.
+        """
+        with tempfile.TemporaryDirectory() as tempdir:
+            with self.settings(GIT_ROOT=tempdir):
+                # Initially have a successful sync to a good commit that provides data
+                self.repo.branch = "valid-files"  # actually a tag
+                self.repo.save()
+                job_model = GitRepositorySync().job_model
+                job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
+                job_result.refresh_from_db()
+                self.assertEqual(
+                    job_result.status,
+                    JobResultStatusChoices.STATUS_SUCCESS,
+                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
+                )
+
+                self.assert_explicit_config_context_exists("Frobozz 1000 NTP servers")
+                self.assert_implicit_config_context_exists("Location context")
+                self.assert_config_context_schema_record_exists("Config Context Schema 1")
+                self.assert_device_exists(self.device.name)
+                self.assert_export_template_device("template.j2")
+                self.assert_export_template_html_exist("template2.html")
+                self.assert_export_template_vlan_exists("template.j2")
+                self.assert_job_exists(name="MyJob")
+                self.assert_job_exists(name="MyJobButtonReceiver")
+                self.assert_job_exists(name="MyJobHookReceiver")
+
+                # Create JobButton and JobHook
+                JobButton.objects.create(
+                    name="MyJobButton", enabled=True, text="Click me", job=Job.objects.get(name="MyJobButtonReceiver")
+                )
+                JobHook.objects.create(name="MyJobHook", enabled=True, job=Job.objects.get(name="MyJobHookReceiver"))
+
+                self.repo.refresh_from_db()
+                self.assertNotEqual(self.repo.current_head, "")
+                good_current_head = self.repo.current_head
+
+                # Now change to the `main` branch (which includes the current commit, followed by a "bad" commit)
+                self.repo.branch = "main"
+                self.repo.save()
+
+                # Resync, attempting and failing to update to the new commit
+                job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
+                job_result.refresh_from_db()
+                self.assertEqual(
+                    job_result.status,
+                    JobResultStatusChoices.STATUS_FAILURE,
+                    job_result.result,
+                )
+                log_entries = JobLogEntry.objects.filter(job_result=job_result)
+
+                # Assert database changes were rolled back
+                self.repo.refresh_from_db()
+                try:
+                    self.assertEqual(self.repo.current_head, good_current_head)
+                    self.assert_explicit_config_context_exists("Frobozz 1000 NTP servers")
+                    self.assert_implicit_config_context_exists("Location context")
+                    self.assert_config_context_schema_record_exists("Config Context Schema 1")
+                    self.assert_device_exists(self.device.name)
+                    self.assert_export_template_device("template.j2")
+                    self.assert_export_template_html_exist("template2.html")
+                    self.assert_export_template_vlan_exists("template.j2")
+                    self.assert_job_exists(name="MyJob")
+                    self.assert_job_exists(name="MyJobButtonReceiver")
+                    self.assert_job_exists(name="MyJobHookReceiver")
+                    self.assertTrue(JobButton.objects.get(name="MyJobButton").enabled)
+                    self.assertTrue(JobHook.objects.get(name="MyJobHook").enabled)
+                except Exception:
+                    for log in log_entries:
+                        print(log.message)
+                    print(job_result.traceback)
+                    raise
+
     def test_git_dry_run(self):
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):