nautobot 3.0.0a2__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/dcim/templates/dcim/rack_retrieve.html

@@ -2,25 +2,43 @@
 {% load helpers %}
 {% load static %}
 
-{% block extra_buttons %}
-    <a {% if prev_rack %}href="{% url 'dcim:rack' pk=prev_rack.pk %}"{% else %}disabled="disabled"{% endif %} class="btn btn-primary">
-        <span class="mdi mdi-chevron-left" aria-hidden="true"></span> Previous Rack
-    </a>
-    <a {% if next_rack %}href="{% url 'dcim:rack' pk=next_rack.pk %}"{% else %}disabled="disabled"{% endif %} class="btn btn-primary">
-        <span class="mdi mdi-chevron-right" aria-hidden="true"></span> Next Rack
-    </a>
-{% endblock extra_buttons %}
+{% block extra_styles %}
+<!-- Invert the rack elevation in dark mode as a quick fix until we have a proper dark mode svg generation -->
+    <style>
+        [data-theme="dark"] .rack_elevation {
+            filter: invert(1) hue-rotate(180deg);
+        }
+    </style>
+{% endblock %}
 
-{% block title %}Rack {{ object }}{% endblock title %}
-
-{% block panel_buttons %}
-    <button class="btn btn-sm btn-secondary toggle-fullname" selected="selected">
+{% block extra_buttons %}
+    {% if prev_rack %}
+        <a href="{% url 'dcim:rack' pk=prev_rack.pk %}" class="btn btn-primary">
+            <span class="mdi mdi-chevron-left" aria-hidden="true"></span> Previous Rack
+        </a>
+    {% else %}
+        <a aria-disabled="true" class="btn btn-primary disabled">
+            <span class="mdi mdi-chevron-left" aria-hidden="true"></span> Previous Rack
+        </a>
+    {% endif %}
+    {% if next_rack %}
+        <a href="{% url 'dcim:rack' pk=next_rack.pk %}" class="btn btn-primary">
+            <span class="mdi mdi-chevron-right" aria-hidden="true"></span> Next Rack
+        </a>
+    {% else %}
+        <a aria-disabled="true" class="btn btn-primary disabled">
+            <span class="mdi mdi-chevron-right" aria-hidden="true"></span> Next Rack
+        </a>
+    {% endif %}
+    <button class="btn btn-secondary toggle-fullname" selected="selected">
         <span class="mdi mdi-checkbox-marked-circle-outline" aria-hidden="true"></span> Show Device Full Name
     </button>
-    <button class="btn btn-sm btn-secondary toggle-images" selected="selected">
+    <button class="btn btn-secondary toggle-images" selected="selected">
         <span class="mdi mdi-checkbox-marked-circle-outline" aria-hidden="true"></span> Show Images
     </button>
-{% endblock panel_buttons %}
+{% endblock extra_buttons %}
+
+{% block title %}Rack {{ object }}{% endblock title %}
 
 {% block content_left_page %}
     <div class="card">
@@ -160,7 +178,7 @@
                             <span class="badge" style="color: {{ powerfeed.status.color|fgcolor }}; background-color: #{{powerfeed.status.color}}">{{ powerfeed.get_status_display }}</span>
                         </td>
                         <td>
-                            <span class="badge badge-{{ powerfeed.get_type_class }}">{{ powerfeed.get_type_display }}</span>
+                            <span class="badge bg-{{ powerfeed.get_type_class }}">{{ powerfeed.get_type_display }}</span>
                         </td>
                         {% with power_port=powerfeed.connected_endpoint %}
                             {% if power_port %}

nautobot/dcim/templates/dcim/rearport.html

@@ -72,14 +72,15 @@
                 Not connected
                 {% if perms.dcim.add_cable %}
                     <span class="dropdown float-end">
-                        <button type="button" class="btn btn-primary btn-sm dropdown-toggle" data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+                        {# comment The "fixed" strategy allows the dropdown to break out of the containing card #}
+                        <button type="button" class="btn btn-primary btn-sm dropdown-toggle" data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false" data-bs-popper-config='{"strategy": "fixed"}'>
                             <span class="mdi mdi-ethernet-cable" aria-hidden="true"></span> Connect
                         </button>
-                        <ul class="dropdown-menu dropdown-menu-right">
-                            <li><a href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='interface' %}?return_url={{ object.get_absolute_url }}">Interface</a></li>
-                            <li><a href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='front-port' %}?return_url={{ object.get_absolute_url }}">Front Port</a></li>
-                            <li><a href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='rear-port' %}?return_url={{ object.get_absolute_url }}">Rear Port</a></li>
-                            <li><a href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='circuit-termination' %}?return_url={{ object.get_absolute_url }}">Circuit Termination</a></li>
+                        <ul class="dropdown-menu dropdown-menu-end">
+                            <li><a class="dropdown-item" href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='interface' %}?return_url={{ object.get_absolute_url }}">Interface</a></li>
+                            <li><a class="dropdown-item" href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='front-port' %}?return_url={{ object.get_absolute_url }}">Front Port</a></li>
+                            <li><a class="dropdown-item" href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='rear-port' %}?return_url={{ object.get_absolute_url }}">Rear Port</a></li>
+                            <li><a class="dropdown-item" href="{% url 'dcim:rearport_connect' termination_a_id=object.pk termination_b_type='circuit-termination' %}?return_url={{ object.get_absolute_url }}">Circuit Termination</a></li>
                         </ul>
                     </span>
                 {% endif %}

nautobot/dcim/templates/dcim/virtualchassis.html

@@ -1,2 +1,2 @@
-{% extends 'dcim/virtualchassis_retrieve.html' %}
+{% extends 'generic/object_retrieve.html' %}
 {% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/dcim/templates/dcim/virtualchassis_add_member.html

@@ -3,25 +3,27 @@
 
 {% block content %}
     <form action="" method="post" enctype="multipart/form-data" class="h-100 vstack">
-        {% csrf_token %}b
-        <div class="col-xl-8 offset-lg-2 col-lg-10 offset-md-1">
+        {% csrf_token %}
+        <div class="row justify-content-center">
             <h3 class="mb-16">{% block title %}Add New Member to Virtual Chassis {{ virtual_chassis }}{% endblock %}</h3>
-            {% if membership_form.non_field_errors %}
-                <div class="card border-danger">
-                    <div class="card-header bg-danger-subtle border-danger text-body">
-                        <strong>Errors</strong>
+            <div class="col-xl-8 col-lg-10">
+                {% if membership_form.non_field_errors %}
+                    <div class="card border-danger">
+                        <div class="card-header bg-danger-subtle border-danger text-body">
+                            <strong>Errors</strong>
+                        </div>
+                        <div class="card-body">
+                            {{ membership_form.non_field_errors }}
+                        </div>
                     </div>
+                {% endif %}
+                <div class="card">
+                    <div class="card-header"><strong>Add New Member</strong></div>
                     <div class="card-body">
-                        {{ membership_form.non_field_errors }}
+                        {% render_form member_select_form %}
+                        {% render_form membership_form %}
                     </div>
                 </div>
-            {% endif %}
-            <div class="card">
-                <div class="card-header"><strong>Add New Member</strong></div>
-                <div class="card-body">
-                    {% render_form member_select_form %}
-                    {% render_form membership_form %}
-                </div>
             </div>
         </div>
         <div class="nb-form-sticky-footer">

nautobot/dcim/templates/dcim/virtualchassis_update.html

@@ -2,14 +2,15 @@
 {% load helpers %}
 {% load form_helpers %}
 
+{% block title %}{% if vc_form.instance %}Editing {{ vc_form.instance }}{% else %}New Virtual Chassis{% endif %}{% endblock %}
+
 {% block content %}
     <form action="" method="post" enctype="multipart/form-data" class="h-100 vstack">
         {% csrf_token %}
         {{ pk_form.pk }}
         {{ formset.management_form }}
-        <div class="row align-content-start flex-fill">
-            <div class="col-xl-8 offset-lg-2 col-lg-10 offset-md-1">
-                <h3 class="mb-16">{% block title %}{% if vc_form.instance %}Editing {{ vc_form.instance }}{% else %}New Virtual Chassis{% endif %}{% endblock %}</h3>
+        <div class="row justify-content-center flex-fill">
+            <div class="col-xl-8 col-lg-10">
                 {% if vc_form.non_field_errors %}
                     <div class="card border-danger">
                         <div class="card-header bg-danger-subtle border-danger text-body">
@@ -72,9 +73,16 @@
                                         </td>
                                         <td>
                                             {% if virtual_chassis.present_in_database %}
-                                                <a href="{% url 'dcim:virtualchassis_remove_member' pk=device.pk %}?return_url={% url 'dcim:virtualchassis_edit' pk=virtual_chassis.pk %}" class="btn btn-danger btn-sm{% if virtual_chassis.master == device %} disabled{% endif %}">
-                                                    <span class="mdi mdi-trash-can-outline" aria-hidden="true"></span>
-                                                </a>
+                                                {% if virtual_chassis.master != device %}
+                                                    <a href="{% url 'dcim:virtualchassis_remove_member' pk=device.pk %}?return_url={% url 'dcim:virtualchassis_edit' pk=virtual_chassis.pk %}"
+                                                       class="btn btn-danger btn-sm">
+                                                        <span class="mdi mdi-trash-can-outline" aria-hidden="true"></span>
+                                                    </a>
+                                                {% else %}
+                                                    <a aria-disabled="true" class="btn btn-danger btn-sm disabled">
+                                                        <span class="mdi mdi-trash-can-outline" aria-hidden="true"></span>
+                                                    </a>
+                                                {% endif %}
                                             {% endif %}
                                         </td>
                                     </tr>

nautobot/dcim/tests/integration/test_controller.py

@@ -38,6 +38,7 @@ class ControllerTestCase(SeleniumTestCase):
 
         # Create Controller
         self.click_navbar_entry("Devices", "Controllers")
+
         self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controller_list"))
         self.click_list_view_add_button()
         self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:controller_add"))

nautobot/dcim/tests/test_api.py

@@ -1471,6 +1471,9 @@ class PlatformTest(APIViewTestCases.APIViewTestCase):
 class DeviceTest(APIViewTestCases.APIViewTestCase):
     model = Device
     choices_fields = ["face"]
+    validation_excluded_fields = [
+        "software_image_files",  # M2M field, excluded by default
+    ]
 
     @classmethod
     def setUpTestData(cls):
@@ -2168,6 +2171,9 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
     model = Interface
     peer_termination_type = Interface
     choices_fields = ["mode", "type"]
+    validation_excluded_fields = [
+        "tagged_vlans",  # M2M field, excluded by default
+    ]
 
     @classmethod
     def setUpTestData(cls):
@@ -3588,6 +3594,7 @@ class DeviceTypeToSoftwareImageFileTestCase(
 
 class ControllerTestCase(APIViewTestCases.APIViewTestCase):
     model = Controller
+    choices_fields = ("capabilities",)
 
     def get_deletable_object(self):
         # This method is used in `test_recreate_object_csv`,
@@ -3647,6 +3654,7 @@ class ControllerTestCase(APIViewTestCases.APIViewTestCase):
 
 class ControllerManagedDeviceGroupTestCase(APIViewTestCases.APIViewTestCase):
     model = ControllerManagedDeviceGroup
+    choices_fields = ("capabilities",)
 
     def get_deletable_object(self):
         # This method is used in `test_recreate_object_csv`,

nautobot/dcim/tests/test_custom_validators.py

@@ -0,0 +1,229 @@
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
+from django.test import override_settings, TestCase
+
+from nautobot.core.testing.mixins import NautobotTestCaseMixin
+from nautobot.data_validation.models import RequiredValidationRule
+from nautobot.dcim.choices import DeviceUniquenessChoices
+from nautobot.dcim.models import Device, DeviceType, Location
+from nautobot.extras.models import Role, Status
+from nautobot.tenancy.models import Tenant
+
+
+class DeviceUniquenessValidatorTest(NautobotTestCaseMixin, TestCase):
+    """Tests for the DeviceUniquenessValidator custom validator."""
+
+    def setUp(self):
+        super().setUp()
+        self.device_status = Status.objects.get_for_model(Device).first()
+        self.device_type = DeviceType.objects.first()
+        self.device_role = Role.objects.get_for_model(Device).first()
+        self.location = Location.objects.first()
+        self.tenant = Tenant.objects.create(name="Tenant")
+        self.device_name = "Device"
+        self.device = Device.objects.create(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_duplicate_same_location_tenant_name_fails(self):
+        """Same name, tenant, and location should raise ValidationError."""
+        dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+        with self.assertRaises(ValidationError) as contextmanager:
+            dup_device.full_clean()
+        self.assertIn(
+            f"A device named '{self.device_name}' already exists in this location: {self.location} and tenant: {self.tenant}. ",
+            str(contextmanager.exception),
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_different_tenant_allows_duplicate_name(self):
+        """Same name and location, different tenant should be allowed."""
+        tenant = Tenant.objects.create(name="Tenant2")
+        non_dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=tenant,
+        )
+        non_dup_device.full_clean()  # should not raise
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_different_location_allows_duplicate_name(self):
+        """Same name and tenant, different location should be allowed."""
+        location = Location.objects.last()
+        non_dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+        non_dup_device.full_clean()  # should not raise
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME)
+    def test_duplicate_name_with_null_tenant_fails(self):
+        """Duplicate name with tenant=None should raise ValidationError."""
+        Device.objects.create(
+            name="Device-2",
+            location=self.location,
+            tenant=None,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        dup = Device(
+            name="Device-2",
+            location=self.location,
+            tenant=None,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        with self.assertRaises(ValidationError) as contextmanager:
+            dup.full_clean()
+        self.assertIn(
+            f"A device named '{dup.name}' with no tenant already exists in this location: {self.location}. ",
+            str(contextmanager.exception),
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME)
+    def test_duplicate_name_globally_fails(self):
+        """Duplicate name should raise ValidationError."""
+        tenant = Tenant.objects.create(name="Tenant2")
+        location = Location.objects.last()
+        dup_device = Device(
+            name=self.device_name,
+            device_type=self.device_type,
+            role=self.device_role,
+            location=location,
+            status=self.device_status,
+            tenant=tenant,
+        )
+        with self.assertRaises(ValidationError) as contextmanager:
+            dup_device.full_clean()
+        self.assertIn(
+            f"At least one other device named '{dup_device.name}' already exists. ", str(contextmanager.exception)
+        )
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME)
+    def test_different_name_succeeds(self):
+        """Different name should be allowed globally."""
+        non_dup_device = Device(
+            name="Device-2",
+            device_type=self.device_type,
+            role=self.device_role,
+            location=self.location,
+            status=self.device_status,
+            tenant=self.tenant,
+        )
+        non_dup_device.full_clean()  # should not raise
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME)
+    def test_unnamed_device_allowed_if_name_not_required(self):
+        """Unnamed device allowed if DEVICE_NAME_REQUIRED is False."""
+        Device.objects.create(
+            name=None,
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        unnamed2 = Device(
+            name=None,
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        self.assertFalse(
+            RequiredValidationRule.objects.filter(
+                content_type=ContentType.objects.get_for_model(Device), field="name"
+            ).exists()
+        )
+        unnamed2.full_clean()  # should not raise
+
+    def test_unnamed_device_fails_if_name_is_required(self):
+        """Unnamed device should raise a ValidationError if DEVICE_NAME_REQUIRED is True."""
+        unnamed = Device(
+            name=None,
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        RequiredValidationRule.objects.create(content_type=ContentType.objects.get_for_model(Device), field="name")
+        with self.assertRaises(ValidationError) as contextmanager:
+            unnamed.full_clean()
+        # This error is from RequiredValidationRule
+        self.assertIn("{'name': ['This field cannot be blank.']}", str(contextmanager.exception))
+
+    def test_empty_device_fails_if_name_is_required(self):
+        """Empty name device should raise a ValidationError if DEVICE_NAME_REQUIRED is True."""
+        unnamed = Device(
+            name="",
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        RequiredValidationRule.objects.create(content_type=ContentType.objects.get_for_model(Device), field="name")
+        with self.assertRaises(ValidationError) as contextmanager:
+            unnamed.full_clean()
+        # This error is from RequiredValidationRule
+        self.assertIn("{'name': ['This field cannot be blank.']}", str(contextmanager.exception))
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE)
+    def test_no_uniqueness_enforced(self):
+        """Devices should not trigger validation errors when uniqueness is disabled."""
+        dup_device = Device(
+            name=self.device.name,
+            location=self.location,
+            tenant=self.tenant,
+            role=self.device_role,
+            device_type=self.device_type,
+            status=self.device_status,
+        )
+
+        # Should NOT raise any error since uniqueness enforcement is off
+        dup_device.full_clean()
+
+    @override_settings(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE)
+    def test_allow_duplicate_devices_with_empty_name_when_uniqueness_is_none(self):
+        """Allow duplicate devices with empty name when DEVICE_UNIQUENESS="none"."""
+        Device.objects.create(
+            name="",
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        empty_name = Device(
+            name="",
+            location=self.location,
+            tenant=self.tenant,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        empty_name.full_clean()

nautobot/dcim/tests/test_filters.py

@@ -124,8 +124,9 @@ from nautobot.dcim.models import (
     VirtualChassis,
     VirtualDeviceContext,
 )
-from nautobot.extras.filters.mixins import RoleFilter, StatusFilter
+from nautobot.extras.filter_mixins import RoleFilter, StatusFilter
 from nautobot.extras.models import ExternalIntegration, Role, SecretsGroup, Status, Tag
+from nautobot.extras.tests.test_customfields_filters import CustomFieldsFilters
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, ClusterType, VirtualMachine
@@ -1039,7 +1040,9 @@ class PathEndpointModelTestMixin:
             )
 
 
-class LocationTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
+class LocationTypeFilterSetTestCase(
+    FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin
+):
     queryset = LocationType.objects.all()
     filterset = LocationTypeFilterSet
     generic_filter_tests = [
@@ -1076,7 +1079,10 @@ class LocationTypeFilterSetTestCase(FilterTestCases.FilterTestCase):
             )
 
 
-class LocationFilterSetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
+class LocationFilterSetTestCase(
+    FilterTestCases.FilterTestCase,
+    FilterTestCases.TenancyFilterTestCaseMixin,
+):
     queryset = Location.objects.all()
     filterset = LocationFilterSet
     tenancy_related_name = "locations"
@@ -1149,7 +1155,7 @@ class LocationFilterSetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.
         )
 
 
-class RackGroupTestCase(FilterTestCases.FilterTestCase):
+class RackGroupTestCase(FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin):
     queryset = RackGroup.objects.all()
     filterset = RackGroupFilterSet
     generic_filter_tests = [
@@ -1357,7 +1363,7 @@ class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.Te
         common_test_data(cls)
 
 
-class ManufacturerTestCase(FilterTestCases.FilterTestCase):
+class ManufacturerTestCase(FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin):
     queryset = Manufacturer.objects.all()
     filterset = ManufacturerFilterSet
     generic_filter_tests = [
@@ -1393,7 +1399,7 @@ class DeviceFamilyTestCase(FilterTestCases.FilterTestCase):
     ]
 
 
-class DeviceTypeTestCase(FilterTestCases.FilterTestCase):
+class DeviceTypeTestCase(FilterTestCases.FilterTestCase, CustomFieldsFilters.CustomFieldsFilterSetTestCaseMixin):
     queryset = DeviceType.objects.all()
     filterset = DeviceTypeFilterSet
     generic_filter_tests = [

nautobot/dcim/tests/test_models.py

@@ -2,6 +2,7 @@ from decimal import Decimal
 
 from constance.test import override_config
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import caches
 from django.core.exceptions import ValidationError
 from django.db import IntegrityError
 from django.db.models import Model
@@ -16,6 +17,7 @@ from nautobot.dcim.choices import (
     CableTypeChoices,
     ConsolePortTypeChoices,
     DeviceFaceChoices,
+    DeviceUniquenessChoices,
     InterfaceModeChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
@@ -1423,6 +1425,10 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
     model = Device
 
     def setUp(self):
+        # clear Constance cache
+        cache = caches[settings.CONSTANCE_DATABASE_CACHE_BACKEND]
+        cache.clear()
+
         manufacturer = Manufacturer.objects.first()
         self.device_type = DeviceType.objects.create(
             manufacturer=manufacturer,
@@ -1532,12 +1538,25 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
 
     def test_natural_key_overrides(self):
         """Ensure that the natural-key for Device is affected by settings/Constance."""
-        with override_config(DEVICE_NAME_AS_NATURAL_KEY=True):
+        with override_config(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NAME):
             self.assertEqual([self.device.name], self.device.natural_key())
             # self.assertEqual(construct_composite_key([self.device.name]), self.device.composite_key)  # TODO: Revist this if we reintroduce composite keys
             self.assertEqual(self.device, Device.objects.get_by_natural_key([self.device.name]))
             # self.assertEqual(self.device, Device.objects.get(composite_key=self.device.composite_key))  # TODO: Revist this if we reintroduce composite keys
 
+        with override_config(DEVICE_UNIQUENESS=DeviceUniquenessChoices.LOCATION_TENANT_NAME):
+            self.assertEqual(
+                [self.device.name, self.device.tenant, self.device.location.name], self.device.natural_key()
+            )
+            self.assertEqual(
+                self.device,
+                Device.objects.get_by_natural_key([self.device.name, self.device.tenant, self.device.location]),
+            )
+
+        with override_config(DEVICE_UNIQUENESS=DeviceUniquenessChoices.NONE):
+            self.assertEqual([str(self.device.pk)], self.device.natural_key())
+            self.assertEqual(self.device, Device.objects.get_by_natural_key([self.device.pk]))
+
         with override_config(LOCATION_NAME_AS_NATURAL_KEY=True):
             self.assertEqual([self.device.name, None, self.device.location.name], self.device.natural_key())
             # self.assertEqual(
@@ -2899,6 +2918,11 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.assertEqual(count, 1)
         self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ips[-1], interface=interface).count(), 1)
 
+        # add a single instance which is already there
+        count = interface.add_ip_addresses(ips[-1])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ips[-1], interface=interface).count(), 1)
+
         # add multiple instances
         count = interface.add_ip_addresses(ips[:5])
         self.assertEqual(count, 5)
@@ -2906,6 +2930,20 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         for ip in ips[:5]:
             self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, interface=interface).count(), 1)
 
+        # add multiple instances all of which are already there
+        count = interface.add_ip_addresses(ips[:5])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 6)
+        for ip in ips[:5]:
+            self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, interface=interface).count(), 1)
+
+        # add multiple IPs some of which are there
+        count = interface.add_ip_addresses(ips[3:7])
+        self.assertEqual(count, 2)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 8)
+        for ip in ips[3:7]:
+            self.assertEqual(IPAddressToInterface.objects.filter(ip_address=ip, interface=interface).count(), 1)
+
     def test_remove_ip_addresses(self):
         """Test the `remove_ip_addresses` helper method on `Interface`"""
         interface = Interface.objects.create(
@@ -2928,13 +2966,28 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.assertEqual(count, 1)
         self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 9)
 
+        # remove a single instance which has already been removed
+        count = interface.remove_ip_addresses(ips[-1])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 9)
+
         # remove multiple instances
         count = interface.remove_ip_addresses(ips[:5])
         self.assertEqual(count, 5)
         self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 4)
 
+        # remove multiple instances all which have already been removed
+        count = interface.remove_ip_addresses(ips[:5])
+        self.assertEqual(count, 0)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 4)
+
+        # remove multiple instances some of which have already been removed
+        count = interface.remove_ip_addresses(ips[3:7])
+        self.assertEqual(count, 2)
+        self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 2)
+
         count = interface.remove_ip_addresses(ips)
-        self.assertEqual(count, 4)
+        self.assertEqual(count, 2)
         self.assertEqual(IPAddressToInterface.objects.filter(interface=interface).count(), 0)
 
         # Test the pre_delete signal for IPAddressToInterface instances
@@ -2942,10 +2995,16 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.device.primary_ip4 = interface.ip_addresses.all().filter(ip_version=4).first()
         self.device.primary_ip6 = interface.ip_addresses.all().filter(ip_version=6).first()
         self.device.save()
-        interface.remove_ip_addresses(self.device.primary_ip4)
+
+        count = interface.remove_ip_addresses(self.device.primary_ip4)
+        self.assertEqual(count, 1)
         self.device.refresh_from_db()
         self.assertEqual(self.device.primary_ip4, None)
-        interface.remove_ip_addresses(self.device.primary_ip6)
+        # NOTE: This effectively tests what happens when you pass remove_ip_addresses None; it
+        # NOTE: does not remove a v6 address, because there are no v6 IPs created in this test
+        # NOTE: class.
+        count = interface.remove_ip_addresses(self.device.primary_ip6)
+        self.assertEqual(count, 0)
         self.device.refresh_from_db()
         self.assertEqual(self.device.primary_ip6, None)