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

nautobot/extras/models/groups.py

@@ -8,6 +8,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db import models
+from django.db.models.signals import pre_delete
 from django.utils.functional import cached_property
 import django_filters
 
@@ -319,24 +320,18 @@ class DynamicGroup(PrimaryModel):
         if isinstance(value, models.QuerySet):
             if value.model != self.model:
                 raise TypeError(f"QuerySet does not contain {self.model._meta.label_lower} objects")
-            to_remove = self.members.exclude(pk__in=value.values_list("pk", flat=True))
+            to_remove = self.members.only("id").difference(value.only("id"))
             self._remove_members(to_remove)
-            to_add = value.exclude(pk__in=self.members.values_list("pk", flat=True))
+            to_add = value.only("id").difference(self.members.only("id"))
             self._add_members(to_add)
         else:
             for obj in value:
                 if not isinstance(obj, self.model):
                     raise TypeError(f"{obj} is not a {self.model._meta.label_lower}")
-            to_remove = []
-            for member in self.members:
-                if member not in value:
-                    to_remove.append(member)
+            existing_members = self.members
+            to_remove = [obj for obj in existing_members if obj not in value]
             self._remove_members(to_remove)
-            to_add = []
-            members = self.members
-            for candidate in value:
-                if candidate not in members:
-                    to_add.append(candidate)
+            to_add = [obj for obj in value if obj not in existing_members]
             self._add_members(to_add)
 
         return self.members
@@ -345,63 +340,81 @@ class DynamicGroup(PrimaryModel):
         """Add the given list or QuerySet of objects to this staticly defined group."""
         if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
             raise ValidationError(f"Group {self} is not staticly defined, adding members directly is not permitted.")
-        return self._add_members(objects_to_add)
-
-    def _add_members(self, objects_to_add):
-        """Internal API for adding the given list or QuerySet of objects to the cached/static members of this group."""
         if isinstance(objects_to_add, models.QuerySet):
             if objects_to_add.model != self.model:
                 raise TypeError(f"QuerySet does not contain {self.model._meta.label_lower} objects")
+            objects_to_add = objects_to_add.only("id").difference(self.members.only("id"))
         else:
             for obj in objects_to_add:
                 if not isinstance(obj, self.model):
                     raise TypeError(f"{obj} is not a {self.model._meta.label_lower}")
+            existing_members = self.members
+            objects_to_add = [obj for obj in objects_to_add if obj not in existing_members]
+        return self._add_members(objects_to_add)
 
+    def _add_members(self, objects_to_add):
+        """
+        Internal API for adding the given list or QuerySet of objects to the cached/static members of this group.
+
+        Assumes that objects_to_add has already been filtered to exclude any existing member objects.
+        """
         if self.group_type == DynamicGroupTypeChoices.TYPE_STATIC:
             for obj in objects_to_add:
                 # We don't use `.bulk_create()` currently because we want change logging for these creates.
                 # Might be a good future performance improvement though.
-                StaticGroupAssociation.all_objects.get_or_create(
+                StaticGroupAssociation.all_objects.create(
                     dynamic_group=self, associated_object_type=self.content_type, associated_object_id=obj.pk
                 )
         else:
             # Cached/hidden static group associations, so we can use bulk-create to bypass change logging.
-            existing_members = self.members
             sgas = [
                 StaticGroupAssociation(
                     dynamic_group=self, associated_object_type=self.content_type, associated_object_id=obj.pk
                 )
                 for obj in objects_to_add
-                if obj not in existing_members
             ]
-            StaticGroupAssociation.all_objects.bulk_create(sgas)
+            StaticGroupAssociation.all_objects.bulk_create(sgas, batch_size=1000)
 
     def remove_members(self, objects_to_remove):
         """Remove the given list or QuerySet of objects from this staticly defined group."""
         if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
             raise ValidationError(f"Group {self} is not staticly defined, removing members directly is not permitted.")
-        return self._remove_members(objects_to_remove)
-
-    def _remove_members(self, objects_to_remove):
-        """Internal API for removing the given list or QuerySet from the cached/static members of this Group."""
         if isinstance(objects_to_remove, models.QuerySet):
             if objects_to_remove.model != self.model:
                 raise TypeError(f"QuerySet does not contain {self.model._meta.label_lower} objects")
-            StaticGroupAssociation.all_objects.filter(
-                dynamic_group=self,
-                associated_object_type=self.content_type,
-                associated_object_id__in=objects_to_remove.values_list("pk", flat=True),
-            ).delete()
         else:
-            pks_to_remove = set()
             for obj in objects_to_remove:
                 if not isinstance(obj, self.model):
                     raise TypeError(f"{obj} is not a {self.model._meta.label_lower}")
-                pks_to_remove.add(obj.pk)
+        return self._remove_members(objects_to_remove)
 
-            StaticGroupAssociation.all_objects.filter(
-                dynamic_group=self, associated_object_type=self.content_type, associated_object_id__in=pks_to_remove
-            ).delete()
+    def _remove_members(self, objects_to_remove):
+        """Internal API for removing the given list or QuerySet from the cached/static members of this Group."""
+        from nautobot.extras.signals import _handle_deleted_object  # avoid circular import
+
+        # For non-static groups, we aren't going to change log the StaticGroupAssociation deletes anyway,
+        # so save some performance on signals -- important especially when we're dealing with thousands of records
+        if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
+            logger.debug("Temporarily disconnecting the _handle_deleted_object signal for performance")
+            pre_delete.disconnect(_handle_deleted_object)
+        try:
+            if isinstance(objects_to_remove, models.QuerySet):
+                StaticGroupAssociation.all_objects.filter(
+                    dynamic_group=self,
+                    associated_object_type=self.content_type,
+                    associated_object_id__in=objects_to_remove.values_list("id", flat=True),
+                ).delete()
+            else:
+                pks_to_remove = [obj.id for obj in objects_to_remove]
+                StaticGroupAssociation.all_objects.filter(
+                    dynamic_group=self,
+                    associated_object_type=self.content_type,
+                    associated_object_id__in=pks_to_remove,
+                ).delete()
+        finally:
+            if self.group_type != DynamicGroupTypeChoices.TYPE_STATIC:
+                logger.debug("Re-connecting the _handle_deleted_object signal")
+                pre_delete.connect(_handle_deleted_object)
 
     @property
     @method_deprecated("Members are now cached in the database via StaticGroupAssociations rather than in Redis.")
@@ -430,6 +443,7 @@ class DynamicGroup(PrimaryModel):
             else:
                 raise RuntimeError(f"Unknown/invalid group_type {self.group_type}")
 
+        logger.debug("Refreshing members cache for %s", self)
         self._set_members(members)
         logger.debug("Refreshed cache for %s, now with %d members", self, self.count)
 

nautobot/extras/models/jobs.py

@@ -754,7 +754,7 @@ class JobResult(BaseModel, CustomFieldModel):
         grouping="main",
     ):
         """
-        General-purpose API for storing log messages in a JobResult's 'data' field.
+        General-purpose API for creating JobLogEntry records associated with a JobResult.
 
         message (str): Message to log (an attempt will be made to sanitize sensitive information from this message)
         obj (object): Object associated with this message, if any

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/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,7 +74,7 @@ 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.jobs.enqueue_job_hooks", return_value=True)
     @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
     def test_create_then_delete(self, mock_enqueue_webhooks, mock_enqueue_job_hooks):
         """Test that a create followed by a delete is logged as two changes"""
@@ -88,11 +88,13 @@ 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])])
+        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), mock.call(oc_list[1], may_reload_jobs=False)],
+        )
         mock_enqueue_webhooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
 
     def test_update_then_delete(self):
@@ -307,6 +309,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):

nautobot/extras/tests/test_dynamicgroups.py

@@ -304,6 +304,10 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         sg.add_members(Prefix.objects.filter(ip_version=4))
         self.assertIsInstance(sg.members, PrefixQuerySet)
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=4))
+        # test cumulative construction and alternate code path
+        sg.add_members(list(Prefix.objects.filter(ip_version=6)))
+        self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.all())
+        self.assertEqual(sg.static_group_associations.count(), Prefix.objects.all().count())
         # test duplicate objects aren't re-added
         sg.add_members(Prefix.objects.all())
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.all())
@@ -321,10 +325,18 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         sg.remove_members(list(Prefix.objects.filter(ip_version=4)))
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=6))
         self.assertEqual(sg.static_group_associations.count(), Prefix.objects.filter(ip_version=6).count())
+        # test cumulative removal and alternate code path
+        sg.remove_members(list(Prefix.objects.filter(ip_version=6)))
+        self.assertQuerysetEqual(sg.members, Prefix.objects.none())
+        self.assertEqual(sg.static_group_associations.count(), 0)
 
         # test property setter
         sg.members = Prefix.objects.filter(ip_version=4)
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=4))
+        sg.members = Prefix.objects.filter(ip_version=6)
+        self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=6))
+        sg.members = list(Prefix.objects.filter(ip_version=4))
+        self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=4))
         sg.members = list(Prefix.objects.filter(ip_version=6))
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=6))