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

nautobot/extras/models/customfields.py

@@ -391,6 +391,18 @@ class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
 
     get_for_model.cache_key_prefix = "nautobot.extras.customfield.get_for_model"
 
+    def keys_for_model(self, model):
+        """Return list of all keys for CustomFields assigned to the given model."""
+        concrete_model = model._meta.concrete_model
+        cache_key = f"{self.keys_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}"
+        keys = cache.get(cache_key)
+        if keys is None:
+            keys = list(self.get_for_model(model).values_list("key", flat=True))
+            cache.set(cache_key, keys)
+        return keys
+
+    keys_for_model.cache_key_prefix = "nautobot.extras.customfield.keys_for_model"
+
 
 @extras_features("webhooks")
 class CustomField(

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/tests/test_context_managers.py

@@ -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", return_value=True)
-    @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")
@@ -93,9 +93,14 @@ class WebRequestContextTestCase(TestCase):
         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.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)]
         )
-        mock_enqueue_webhooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
 
     def test_update_then_delete(self):
         """Test that an update followed by a delete is logged as a single delete"""

nautobot/extras/tests/test_relationships.py

@@ -1395,6 +1395,7 @@ class RequiredRelationshipTestMixin:
         # Protected FK to SoftwareVersion prevents deletion
         Controller.objects.all().delete()
         Device.objects.all().update(software_version=None)
+        Device.objects.all().delete()
 
         # Create required relationships:
         device_ct = ContentType.objects.get_for_model(Device)

nautobot/extras/tests/test_webhooks.py

@@ -345,7 +345,7 @@ class WebhookTest(APITestCase):
 
         all_changes = get_changes_for_model(location)
         self.assertEqual(all_changes.count(), 1)
-        mock_enqueue_webhooks.assert_called_once_with(all_changes.first())
+        mock_enqueue_webhooks.assert_called_once_with(all_changes.first(), webhook_queryset=None)
 
     def test_all_webhook_supported_models(self):
         """

nautobot/extras/views.py

@@ -2846,6 +2846,7 @@ class StatusBulkDeleteView(generic.BulkDeleteView):
 
     queryset = Status.objects.all()
     table = tables.StatusTable
+    filterset = filters.StatusFilterSet
 
 
 class StatusDeleteView(generic.ObjectDeleteView):

nautobot/extras/webhooks.py

@@ -6,16 +6,22 @@ from nautobot.extras.registry import registry
 from nautobot.extras.tasks import process_webhook
 
 
-def enqueue_webhooks(object_change):
+def enqueue_webhooks(object_change, webhook_queryset=None):
     """
-    Find Webhook(s) assigned to this instance + action and enqueue them
-    to be processed
+    Find Webhook(s) assigned to this instance + action and enqueue them to be processed.
+
+    Args:
+        object_change (ObjectChange): The change that may trigger Webhooks to be sent.
+        webhook_queryset (QuerySet): Previously retrieved set of Webhooks to potentially send.
+
+    Returns:
+        webhook_queryset (QuerySet): for reuse when processing multiple ObjectChange with the same content-type+action.
     """
     # Determine whether this type of object supports webhooks
     app_label = object_change.changed_object_type.app_label
     model_name = object_change.changed_object_type.model
     if model_name not in registry["model_features"]["webhooks"].get(app_label, []):
-        return
+        return webhook_queryset
 
     # Retrieve any applicable Webhooks
     content_type = object_change.changed_object_type
@@ -24,16 +30,17 @@ def enqueue_webhooks(object_change):
         ObjectChangeActionChoices.ACTION_UPDATE: "type_update",
         ObjectChangeActionChoices.ACTION_DELETE: "type_delete",
     }[object_change.action]
-    webhooks = Webhook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
+    if webhook_queryset is None:
+        webhook_queryset = Webhook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
 
-    if webhooks.exists():
+    if webhook_queryset:  # not .exists() as we *want* to populate the queryset cache
         # fall back to object_data if object_data_v2 is not available
         serialized_data = object_change.object_data_v2
         if serialized_data is None:
             serialized_data = object_change.object_data
 
         # Enqueue the webhooks
-        for webhook in webhooks:
+        for webhook in webhook_queryset:
             args = [
                 webhook.pk,
                 serialized_data,
@@ -45,3 +52,5 @@ def enqueue_webhooks(object_change):
                 object_change.get_snapshots(),
             ]
             process_webhook.apply_async(args=args)
+
+    return webhook_queryset

nautobot/ipam/factory.py

@@ -238,6 +238,9 @@ class VLANFactory(PrimaryModelFactory):
                         lambda: Location.objects.filter(location_type__content_types__in=[vlan_ct]), minimum=0
                     )
                 )
+                if self.vlan_group and self.vlan_group.location:
+                    # add the parent of the vlan group location to the vlan locations
+                    self.locations.add(self.vlan_group.location.ancestors(include_self=True)[0])
 
 
 class VLANGetOrCreateFactory(VLANFactory):

nautobot/ipam/filters.py

@@ -90,6 +90,11 @@ class VRFFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyModelFil
         to_field_name="name",
         label="Device (ID or name)",
     )
+    virtual_machines = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VirtualMachine.objects.all(),
+        to_field_name="name",
+        label="Virtual Machine (ID or name)",
+    )
     prefix = NaturalKeyOrPKMultipleChoiceFilter(
         field_name="prefixes",
         queryset=Prefix.objects.all(),

nautobot/ipam/forms.py

@@ -752,6 +752,7 @@ class VLANForm(NautobotModelForm, TenancyForm):
     )
     vlan_group = DynamicModelChoiceField(
         queryset=VLANGroup.objects.all(),
+        query_params={"location": "$locations"},
         required=False,
     )
 
@@ -779,6 +780,22 @@ class VLANForm(NautobotModelForm, TenancyForm):
         }
 
     def clean(self):
+        vlan_group = self.cleaned_data["vlan_group"]
+        locations = self.cleaned_data["locations"]
+        # Validate Vlan Group Location is one of the ancestors of the VLAN locations specified.
+        if vlan_group and vlan_group.location and locations:
+            vlan_group_location = vlan_group.location
+            is_vlan_group_valid = False
+            for location in locations:
+                if vlan_group_location in location.ancestors(include_self=True):
+                    is_vlan_group_valid = True
+                    break
+
+            if not is_vlan_group_valid:
+                locations = list(locations.values_list("name", flat=True))
+                raise ValidationError(
+                    {"vlan_group": [f"VLAN Group {vlan_group} is not in locations {locations} or their ancestors."]}
+                )
         # Validation error raised in signal is not properly handled in form clean
         # Hence handling any validationError that might occur.
         try:

nautobot/ipam/models.py

@@ -1296,7 +1296,8 @@ class IPAddressToInterface(BaseModel):
 
     def __str__(self):
         if self.interface:
-            return f"{self.ip_address!s} {self.interface.device.name} {self.interface.name}"
+            parent_name = self.interface.parent.name if self.interface.parent else "No Parent"
+            return f"{self.ip_address!s} {parent_name} {self.interface.name}"
         else:
             return f"{self.ip_address!s} {self.vm_interface.virtual_machine.name} {self.vm_interface.name}"
 

nautobot/ipam/signals.py

@@ -65,9 +65,9 @@ def ip_address_to_interface_pre_delete(instance, raw=False, **kwargs):
     # that is the primary_v{version} of the host machine.
 
     if getattr(instance, "interface"):
-        host = instance.interface.device
+        host = instance.interface.parent
         other_assignments_exist = (
-            IPAddressToInterface.objects.filter(interface__device=host, ip_address=instance.ip_address)
+            IPAddressToInterface.objects.filter(interface__in=host.all_interfaces, ip_address=instance.ip_address)
             .exclude(id=instance.id)
             .exists()
         )

nautobot/ipam/tables.py

@@ -346,7 +346,7 @@ class PrefixTable(StatusTableMixin, RoleTableMixin, BaseTable):
     prefix = tables.TemplateColumn(
         template_code=PREFIX_COPY_LINK, attrs={"td": {"class": "text-nowrap"}}, order_by=("network", "prefix_length")
     )
-    # vrf = tables.TemplateColumn(template_code=VRF_LINK, verbose_name="VRF")
+    vrf_count = LinkedCountColumn(viewname="ipam:vrf_list", url_params={"prefixes": "pk"}, verbose_name="VRFs")
     tenant = TenantColumn()
     namespace = tables.Column(linkify=True)
     vlan = tables.Column(linkify=True, verbose_name="VLAN")
@@ -368,7 +368,7 @@ class PrefixTable(StatusTableMixin, RoleTableMixin, BaseTable):
             "type",
             "status",
             "children",
-            # "vrf",
+            "vrf_count",
             "namespace",
             "tenant",
             "location_count",
@@ -384,7 +384,7 @@ class PrefixTable(StatusTableMixin, RoleTableMixin, BaseTable):
             "prefix",
             "type",
             "status",
-            # "vrf",
+            "vrf_count",
             "namespace",
             "tenant",
             "location_count",

nautobot/ipam/templates/ipam/ipaddress_assign.html

@@ -18,7 +18,7 @@
             {% endif %}
         {% endfor %}
         <div class="row">
-            <div class="col-md-6 col-md-offset-3">
+            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                 <h3>Assign an IP Address</h3>
                 {% include 'ipam/inc/ipadress_edit_header.html' with active_tab='assign' %}
                 {% if form.non_field_errors %}
@@ -38,7 +38,7 @@
             </div>
         </div>
         <div class="row">
-            <div class="col-md-6 col-md-offset-3 text-right">
+            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1 text-right">
                 <button type="submit" class="btn btn-primary">Search</button>
                 <a href="{{ return_url }}" class="btn btn-default">Cancel</a>
             </div>

nautobot/ipam/tests/test_models.py

@@ -9,7 +9,7 @@ import netaddr
 
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.dcim import choices as dcim_choices
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType
+from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Module, ModuleBay, ModuleType
 from nautobot.extras.models import Role, Status
 from nautobot.ipam.choices import IPAddressTypeChoices, PrefixTypeChoices, ServiceProtocolChoices
 from nautobot.ipam.models import (
@@ -171,6 +171,118 @@ class IPAddressToInterfaceTest(TestCase):
             IPAddressToInterface.objects.create(vm_interface=None, interface=None, ip_address=ip_addr)
         self.assertIn("Must associate to either an Interface or a VMInterface.", str(cm.exception))
 
+    def test_primary_ip_retained_when_deleted_from_device_or_module_interface(self):
+        """Test primary_ip4 remains set when the same IP is assigned to multiple interfaces and deleted from one."""
+
+        # Create a module bay on the existing device
+        device_module_bay = ModuleBay.objects.create(parent_device=self.test_device, name="Test Bay")
+
+        # Create a module with an interface and add it to the module bay on the device
+        module = Module.objects.create(
+            module_type=ModuleType.objects.first(),
+            status=Status.objects.get_for_model(Module).first(),
+            parent_module_bay=device_module_bay,
+        )
+
+        # Set status for the module interface
+        int_status = Status.objects.get_for_model(Interface).first()
+
+        # Create an interface on the module
+        interface_module = Interface.objects.create(
+            name="eth0_module",
+            module=module,
+            type=dcim_choices.InterfaceTypeChoices.TYPE_1GE_FIXED,
+            status=int_status,
+        )
+
+        # Link the module to the device
+        self.test_device.installed_device = interface_module
+        self.test_device.save()
+
+        # Create IP and assign it to multiple interfaces
+        ip_address = IPAddress.objects.create(address="192.0.2.1/24", namespace=self.namespace, status=self.status)
+        assignment_device_int1 = IPAddressToInterface.objects.create(interface=self.test_int1, ip_address=ip_address)
+        assignment_module_int1 = IPAddressToInterface.objects.create(interface=interface_module, ip_address=ip_address)
+
+        # Set the primary IP on the device
+        self.test_device.primary_ip4 = assignment_device_int1.ip_address
+        self.test_device.save()
+
+        # Verify that the primary IP is set
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Delete the IP assignment from one interface
+        assignment_device_int1.delete()
+
+        # Refresh and check that the primary IP is still assigned
+        self.test_device.refresh_from_db()
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Verify remaining IP assignments on the IP object
+        remaining_assignments = ip_address.interface_assignments.all()
+        self.assertEqual(remaining_assignments.count(), 1)
+        self.assertIn(assignment_module_int1, remaining_assignments)
+
+    def test_primary_ip_retained_when_deleted_from_device_interface_with_nested_module(self):
+        """Test primary_ip4 remains set when the same IP is assigned to a device and nested module interfaces, and deleted from the device interface."""
+
+        # Create a module bay on the existing device
+        device_module_bay = ModuleBay.objects.create(parent_device=self.test_device, name="Primary Module Bay")
+
+        # Create a primary module with an interface and add it to the module bay on the device
+        primary_module = Module.objects.create(
+            module_type=ModuleType.objects.first(),
+            status=Status.objects.get_for_model(Module).first(),
+            parent_module_bay=device_module_bay,
+        )
+
+        # Create a secondary module bay within the primary module for nested module creation
+        nested_module_bay = ModuleBay.objects.create(parent_module=primary_module, name="Nested Module Bay")
+
+        # Create a nested module within the primary module's module bay
+        nested_module = Module.objects.create(
+            module_type=ModuleType.objects.first(),
+            status=Status.objects.get_for_model(Module).first(),
+            parent_module_bay=nested_module_bay,
+        )
+
+        # Set status for the nested module interface
+        int_status = Status.objects.get_for_model(Interface).first()
+
+        # Create an interface on the nested module and assign an IP
+        nested_interface = Interface.objects.create(
+            name="eth0_nested",
+            module=nested_module,
+            type=dcim_choices.InterfaceTypeChoices.TYPE_1GE_FIXED,
+            status=int_status,
+        )
+
+        # Create IP and assign it to both the device and the nested module interface
+        ip_address = IPAddress.objects.create(address="192.0.2.1/24", namespace=self.namespace, status=self.status)
+        assignment_device_int1 = IPAddressToInterface.objects.create(interface=self.test_int1, ip_address=ip_address)
+        assignment_nested_module = IPAddressToInterface.objects.create(
+            interface=nested_interface, ip_address=ip_address
+        )
+
+        # Set the primary IP on the device to the IP on the device interface
+        self.test_device.primary_ip4 = assignment_nested_module.ip_address
+        self.test_device.save()
+
+        # Verify that the primary IP is correctly set
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Delete the IP assignment from the device interface
+        assignment_device_int1.delete()
+
+        # Refresh and check that the primary IP is still assigned to the device
+        self.test_device.refresh_from_db()
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Confirm that the IP is still associated with the nested module interface
+        remaining_assignments = ip_address.interface_assignments.all()
+        self.assertEqual(remaining_assignments.count(), 1)
+        self.assertIn(assignment_nested_module, remaining_assignments)
+
 
 class TestVarbinaryIPField(TestCase):
     """Tests for `nautobot.ipam.fields.VarbinaryIPField`."""