nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/dcim/tests/test_graphql.py

@@ -63,26 +63,22 @@ class GraphQLTestCase(TestCase):
     def test_execute_query(self):
         with self.subTest("device dynamic groups and interfaces query"):
             query = "query {devices {name interfaces {name mac_address} dynamic_groups {name}}}"
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
             self.assertEqual(
-                resp["data"]["devices"][0]["interfaces"][0]["mac_address"], str(self.interfaces[0].mac_address)
+                resp.data["devices"][0]["interfaces"][0]["mac_address"], str(self.interfaces[0].mac_address)
             )
-            self.assertIsNone(resp["data"]["devices"][0]["interfaces"][1]["mac_address"])
-            self.assertEqual(resp["data"]["devices"][0]["dynamic_groups"][0]["name"], self.dynamic_group.name)
+            self.assertIsNone(resp.data["devices"][0]["interfaces"][1]["mac_address"])
+            self.assertEqual(resp.data["devices"][0]["dynamic_groups"][0]["name"], self.dynamic_group.name)
 
         with self.subTest("device platform drivers query"):
             query = "query {devices {platform {network_driver network_driver_mappings}}}"
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            self.assertEqual(resp["data"]["devices"][0]["platform"]["network_driver"], "cisco_ios")
-            self.assertEqual(
-                resp["data"]["devices"][0]["platform"]["network_driver_mappings"]["ansible"], "cisco.ios.ios"
-            )
-            self.assertEqual(resp["data"]["devices"][0]["platform"]["network_driver_mappings"]["netmiko"], "cisco_ios")
-            self.assertEqual(
-                resp["data"]["devices"][0]["platform"]["network_driver_mappings"]["scrapli"], "cisco_iosxe"
-            )
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            self.assertEqual(resp.data["devices"][0]["platform"]["network_driver"], "cisco_ios")
+            self.assertEqual(resp.data["devices"][0]["platform"]["network_driver_mappings"]["ansible"], "cisco.ios.ios")
+            self.assertEqual(resp.data["devices"][0]["platform"]["network_driver_mappings"]["netmiko"], "cisco_ios")
+            self.assertEqual(resp.data["devices"][0]["platform"]["network_driver_mappings"]["scrapli"], "cisco_iosxe")
 
         with self.subTest("device serial number query"):
             non_empty_serial_device = Device.objects.first()
@@ -91,47 +87,47 @@ class GraphQLTestCase(TestCase):
 
             # Test device serial query default behavior: serial__ie
             query = 'query { devices (serial: " ") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            for device in resp["data"]["devices"]:
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            for device in resp.data["devices"]:
                 self.assertEqual(device["serial"], "")
 
             # Test device serial default filter with non-empty serial number
             query = 'query { devices (serial:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            self.assertEqual(resp.data["devices"][0]["serial"], non_empty_serial_device.serial)
 
             # Test device serial iexact filter with non-empty serial number
             query = 'query { devices (serial__ie:"' + non_empty_serial_device.serial.upper() + '") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            self.assertEqual(resp["data"]["devices"][0]["serial"], non_empty_serial_device.serial)
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            self.assertEqual(resp.data["devices"][0]["serial"], non_empty_serial_device.serial)
 
             # Test device serial__nie filter with non-empty serial number
             query = 'query { devices (serial__nie:"' + non_empty_serial_device.serial.lower() + '") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            for device in resp["data"]["devices"]:
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            for device in resp.data["devices"]:
                 self.assertNotEqual(device["serial"], non_empty_serial_device.serial)
 
             # Test device serial__ie filter with empty serial number
             query = 'query { devices (serial__ie:" ") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            for device in resp["data"]["devices"]:
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            for device in resp.data["devices"]:
                 self.assertEqual(device["serial"], "")
 
             # Test device serial__nie filter with empty serial number
             query = 'query { devices (serial__nie:" ") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            for device in resp["data"]["devices"]:
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            for device in resp.data["devices"]:
                 self.assertNotEqual(device["serial"], "")
 
             # Test device serial__n filter with empty serial number
             query = 'query { devices (serial__n:" ") { name serial } }'
-            resp = execute_query(query, user=self.user).to_dict()
-            self.assertFalse(resp["data"].get("error"))
-            for device in resp["data"]["devices"]:
+            resp = execute_query(query, user=self.user)
+            self.assertIsNone(resp.errors)
+            for device in resp.data["devices"]:
                 self.assertNotEqual(device["serial"], "")

nautobot/dcim/tests/test_jobs.py

@@ -95,7 +95,7 @@ class TestSoftwareImageFileTestCase(TransactionTestCase):
 class TestSoftwareVersionTestCase(TransactionTestCase):
     def test_correct_handling_for_model_protected_error(self):
         create_common_data_for_software_related_test_cases()
-        software_version = SoftwareVersion.objects.get(version="Test version 1.0.0")
+        software_version = SoftwareVersion.objects.filter(version="Test version 1.0.0").first()
 
         initial_count = SoftwareVersion.objects.all().count()
         self.add_permissions("dcim.delete_softwareversion")

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,
@@ -39,6 +41,7 @@ from nautobot.dcim.models import (
     Device,
     DeviceBay,
     DeviceBayTemplate,
+    DeviceClusterAssignment,
     DeviceRedundancyGroup,
     DeviceType,
     DeviceTypeToSoftwareImageFile,
@@ -1422,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,
@@ -1510,6 +1517,12 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         )
         self.device.validated_save()
 
+        self.cluster_type = ClusterType.objects.create(name="Test Cluster Type")
+        self.cluster = Cluster.objects.create(
+            name="Test Cluster", cluster_type=self.cluster_type, location=self.location_3
+        )
+        self.device.clusters.add(self.cluster)
+
     def test_natural_key_default(self):
         """Ensure that default natural-key for Device is (name, tenant, location)."""
         self.assertEqual([self.device.name, None, *self.device.location.natural_key()], self.device.natural_key())
@@ -1525,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(
@@ -1644,6 +1670,28 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
             f'Devices may not associate to locations of type "{self.location_type_2.name}"', str(cm.exception)
         )
 
+    def test_device_cluster_location_mismatch(self):
+        with self.subTest("Invalid cluster assignment at creation time"):
+            device = Device(
+                name="Device in different location from cluster",
+                device_type=self.device_type,
+                role=self.device_role,
+                status=self.device_status,
+                location=self.location_2,
+                cluster=self.cluster,  # belongs to self.location_3
+            )
+            with self.assertRaises(ValidationError) as cm:
+                device.validated_save()
+            self.assertIn("does not include", str(cm.exception))
+
+        new_cluster = Cluster.objects.create(
+            name="New Cluster", cluster_type=self.cluster_type, location=self.location_2
+        )
+        with self.subTest("Invalid cluster assignment via Device.clusters m2m manager"):
+            with self.assertRaises(ValidationError) as cm:
+                self.device.clusters.add(new_cluster)  # self.device belongs to self.location_3
+            self.assertIn("does not include", str(cm.exception))
+
     def test_device_redundancy_group_validation(self):
         d2 = Device(
             name="Test Device 2",
@@ -1972,6 +2020,42 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
 
         self.assertNotEqual(child_mtime_after_parent_rack_update_save, child_mtime_after_parent_site_update_save)
 
+    def test_cluster_queries(self):
+        with self.subTest("Assert filtering and excluding `cluster`"):
+            self.assertQuerysetEqualAndNotEmpty(
+                Device.objects.filter(cluster=self.cluster),
+                Device.objects.filter(clusters__in=[self.cluster]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                Device.objects.exclude(cluster=self.cluster),
+                Device.objects.exclude(clusters__in=[self.cluster]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                Device.objects.filter(cluster__in=[self.cluster]),
+                Device.objects.filter(clusters__in=[self.cluster]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                Device.objects.exclude(cluster__in=[self.cluster]),
+                Device.objects.exclude(clusters__in=[self.cluster]),
+            )
+
+        # We use `assertQuerysetEqualAndNotEmpty` for test validation. Including a nullable field could lead
+        # to flaky tests where querysets might return None, causing tests to fail. Therefore, we select
+        # fields that consistently contain values to ensure reliable filtering.
+        query_params = ["name", "cluster_type", "location"]
+
+        for field_name in query_params:
+            with self.subTest(f"Assert cluster__{field_name} query."):
+                value = getattr(self.cluster, field_name)
+                self.assertQuerysetEqualAndNotEmpty(
+                    Device.objects.filter(**{f"cluster__{field_name}": value}),
+                    Device.objects.filter(**{f"clusters__{field_name}": value}),
+                )
+                self.assertQuerysetEqualAndNotEmpty(
+                    Device.objects.exclude(**{f"cluster__{field_name}": value}),
+                    Device.objects.exclude(**{f"clusters__{field_name}": value}),
+                )
+
 
 class DeviceBayTestCase(ModelTestCases.BaseModelTestCase):
     model = DeviceBay
@@ -3956,3 +4040,147 @@ class ModuleFamilyTestCase(ModelTestCases.BaseModelTestCase):
     def test_modulefamily_str(self):
         """Test string representation of ModuleFamily."""
         self.assertEqual(str(self.module_family), "Test Module Family")
+
+
+class DeviceClusterAssignmentTestCase(ModelTestCases.BaseModelTestCase):
+    model = DeviceClusterAssignment
+
+    @classmethod
+    def setUpTestData(cls):
+        # Create necessary objects for testing
+        cls.device_role = Role.objects.get_for_model(Device).first()
+        cls.device_status = Status.objects.get_for_model(Device).first()
+        cls.location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        cls.manufacturer = Manufacturer.objects.first()
+        cls.device_type = DeviceType.objects.create(
+            manufacturer=cls.manufacturer,
+            model="Test Device Type 1",
+        )
+        cls.devices = (
+            Device.objects.create(
+                device_type=cls.device_type,
+                role=cls.device_role,
+                name="Test Device 1",
+                location=cls.location,
+                status=cls.device_status,
+            ),
+            Device.objects.create(
+                device_type=cls.device_type,
+                role=cls.device_role,
+                name="Test Device 2",
+                location=cls.location,
+                status=cls.device_status,
+            ),
+        )
+        cls.cluster_type = ClusterType.objects.create(name="Test Cluster Type")
+        cls.clusters = (
+            Cluster.objects.create(name="Test Cluster 1", cluster_type=cls.cluster_type),
+            Cluster.objects.create(name="Test Cluster 2", cluster_type=cls.cluster_type),
+        )
+        cls.assignment = DeviceClusterAssignment.objects.create(
+            device=cls.devices[0],
+            cluster=cls.clusters[0],
+        )
+
+    def test_create_device_cluster_assignment(self):
+        """Test creating a device-cluster assignment."""
+        assignment = DeviceClusterAssignment(
+            device=self.devices[1],
+            cluster=self.clusters[0],
+        )
+        assignment.validated_save()
+        self.assertTrue(
+            DeviceClusterAssignment.objects.filter(
+                device=self.devices[1],
+                cluster=self.clusters[0],
+            ).exists()
+        )
+        self.assertEqual(self.devices[1].clusters.count(), 1)
+        self.assertEqual(self.devices[1].clusters.first(), self.clusters[0])
+        self.assertEqual(self.clusters[0].devices.count(), 2)
+        self.assertIn(self.devices[0], self.clusters[0].devices.all())
+        self.assertIn(self.devices[1], self.clusters[0].devices.all())
+
+    def test_uniqueness_constraint(self):
+        """Test that a device can't be assigned to the same cluster twice."""
+        duplicate_assignment = DeviceClusterAssignment(
+            device=self.devices[0],
+            cluster=self.clusters[0],
+        )
+        with self.assertRaises(ValidationError):
+            duplicate_assignment.full_clean()
+        with self.assertRaises(IntegrityError):
+            duplicate_assignment.save()
+
+    def test_cascade_on_delete(self):
+        """Test that assignments are deleted when either the device or cluster is deleted."""
+        new_assignment = DeviceClusterAssignment.objects.create(
+            device=self.devices[1],
+            cluster=self.clusters[1],
+        )
+        self.assertTrue(DeviceClusterAssignment.objects.filter(id=new_assignment.id).exists())
+        self.devices[1].delete()
+        self.assertFalse(DeviceClusterAssignment.objects.filter(id=new_assignment.id).exists())
+        another_device = Device.objects.create(
+            device_type=self.device_type,
+            role=self.device_role,
+            name="Test Device 3",
+            location=self.location,
+            status=self.device_status,
+        )
+        another_assignment = DeviceClusterAssignment.objects.create(
+            device=another_device,
+            cluster=self.clusters[1],
+        )
+
+        self.assertTrue(DeviceClusterAssignment.objects.filter(id=another_assignment.id).exists())
+
+        self.clusters[1].delete()
+        self.assertFalse(DeviceClusterAssignment.objects.filter(id=another_assignment.id).exists())
+
+    def test_cluster_property_backward_compatibility(self):
+        """Test the backward-compatible cluster property on Device."""
+        self.assertEqual(self.devices[0].cluster, self.clusters[0])
+
+        device_no_clusters = Device.objects.create(
+            device_type=self.device_type,
+            role=self.device_role,
+            name="Test Device No Clusters",
+            location=self.location,
+            status=self.device_status,
+        )
+        self.assertIsNone(device_no_clusters.cluster)
+
+        device_multi_clusters = Device.objects.create(
+            device_type=self.device_type,
+            role=self.device_role,
+            name="Test Device Multi Clusters",
+            location=self.location,
+            status=self.device_status,
+        )
+        DeviceClusterAssignment.objects.create(device=device_multi_clusters, cluster=self.clusters[0])
+        DeviceClusterAssignment.objects.create(device=device_multi_clusters, cluster=self.clusters[1])
+
+        with self.assertRaises(Cluster.MultipleObjectsReturned):
+            device_multi_clusters.cluster
+        self.assertEqual(device_multi_clusters.clusters.count(), 2)
+        self.assertIn(self.clusters[0], device_multi_clusters.clusters.all())
+        self.assertIn(self.clusters[1], device_multi_clusters.clusters.all())
+
+    def test_cluster_setter_backward_compatibility(self):
+        """Test the backward-compatible cluster setter on Device."""
+        device = Device.objects.create(
+            device_type=self.device_type,
+            role=self.device_role,
+            name="Test Device For Setter",
+            location=self.location,
+            status=self.device_status,
+        )
+        device.cluster = self.clusters[0]
+        self.assertEqual(device.clusters.count(), 1)
+        self.assertEqual(device.clusters.first(), self.clusters[0])
+        device.cluster = self.clusters[1]
+        self.assertEqual(device.clusters.count(), 1)
+        self.assertEqual(device.clusters.first(), self.clusters[1])
+        device.cluster = None
+        self.assertEqual(device.clusters.count(), 0)

nautobot/dcim/tests/test_views.py

@@ -6,7 +6,7 @@ import zoneinfo
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
-from django.test import override_settings
+from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.html import strip_spaces_between_tags
 from netaddr import EUI
@@ -762,7 +762,7 @@ class RackTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         # Validate Power Utilization for PowerFeed 11 is displaying correctly on Rack View.
         power_feed_11_html = """
         <td><div title="Used: 1263&#13;Count: 3840" class="progress text-center">
-            <div class="progress-bar progress-bar-success"
+            <div class="progress-bar bg-success"
                 role="progressbar" aria-valuenow="32" aria-valuemin="0" aria-valuemax="100" style="width: 32%">
                 32%
             </div>
@@ -772,7 +772,7 @@ class RackTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         # Validate Power Utilization for PowerFeed12 is displaying correctly on Rack View.
         power_feed_12_html = """
         <td><div title="Used: 2526&#13;Count: 3840" class="progress text-center">
-            <div class="progress-bar progress-bar-success"
+            <div class="progress-bar bg-success"
                 role="progressbar" aria-valuenow="65" aria-valuemin="0" aria-valuemax="100" style="width: 65%">
                 65%
             </div>
@@ -782,7 +782,7 @@ class RackTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         # Validate Rack Power Utilization for Combined powerfeeds is displaying correctly on the Rack View
         total_utilization_html = """
         <td><div title="Used: 3789&#13;Count: 7680" class="progress text-center">
-            <div class="progress-bar progress-bar-success"
+            <div class="progress-bar bg-success"
                 role="progressbar" aria-valuenow="49" aria-valuemin="0" aria-valuemax="100" style="width: 49%">
                 49%
             </div>
@@ -889,11 +889,11 @@ class DeviceTypeTestCase(
         csv_import_url = job_import_url(ContentType.objects.get_for_model(DeviceType))
         # Dropdown provides both YAML/JSON and CSV import as options
         self.assertInHTML(
-            f'<a href="{yaml_import_url}"><span class="mdi mdi-database-import text-muted" aria-hidden="true"></span> Import from JSON/YAML (single record)</a>',
+            f'<a class="dropdown-item" href="{yaml_import_url}"><span class="mdi mdi-database-import text-secondary" aria-hidden="true"></span> Import from JSON/YAML (single record)</a>',
             content,
         )
         self.assertInHTML(
-            f'<a href="{csv_import_url}"><span class="mdi mdi-database-import text-muted" aria-hidden="true"></span> Import from CSV (multiple records)</a>',
+            f'<a class="dropdown-item" href="{csv_import_url}"><span class="mdi mdi-database-import text-secondary" aria-hidden="true"></span> Import from CSV (multiple records)</a>',
             content,
         )
 
@@ -906,11 +906,11 @@ class DeviceTypeTestCase(
         )
         self.assertInHTML('<input type="hidden" name="export_format" value="yaml">', content)
         self.assertInHTML(
-            '<button type="submit"><span class="mdi mdi-database-export text-muted" aria-hidden="true"></span> Export as YAML</button>',
+            '<button class="dropdown-item" type="submit"><span class="mdi mdi-database-export text-secondary" aria-hidden="true"></span> Export as YAML</button>',
             content,
         )
         self.assertInHTML(
-            '<button type="submit"><span class="mdi mdi-database-export text-muted" aria-hidden="true"></span> Export as CSV</button>',
+            '<button class="dropdown-item" type="submit"><span class="mdi mdi-database-export text-secondary" aria-hidden="true"></span> Export as CSV</button>',
             content,
         )
 
@@ -1239,7 +1239,7 @@ module-bays:
         response_content = response.content.decode(response.charset)
         self.assertHttpStatus(response, 200)
         self.assertInHTML(
-            '<strong class="panel-title">U height</strong>: <ul class="errorlist"><li>Ensure this value is greater than or equal to 0.</li></ul>',
+            '<strong>U height</strong>: <ul class="errorlist"><li>Ensure this value is greater than or equal to 0.</li></ul>',
             response_content,
         )
 
@@ -1293,6 +1293,7 @@ class ModuleTypeTestCase(
             "comments": "changed comment",
         }
 
+    @tag("fix_in_v3")
     def test_list_has_correct_links(self):
         """Assert that the ModuleType list view has import/export buttons for both CSV and YAML/JSON formats."""
         self.add_permissions("dcim.add_moduletype", "dcim.view_moduletype")
@@ -1304,11 +1305,11 @@ class ModuleTypeTestCase(
         csv_import_url = job_import_url(ContentType.objects.get_for_model(ModuleType))
         # Dropdown provides both YAML/JSON and CSV import as options
         self.assertInHTML(
-            f'<a href="{yaml_import_url}"><span class="mdi mdi-database-import text-muted" aria-hidden="true"></span> Import from JSON/YAML (single record)</a>',
+            f'<a href="{yaml_import_url}"><span class="mdi mdi-database-import text-secondary" aria-hidden="true"></span> Import from JSON/YAML (single record)</a>',
             content,
         )
         self.assertInHTML(
-            f'<a href="{csv_import_url}"><span class="mdi mdi-database-import text-muted" aria-hidden="true"></span> Import from CSV (multiple records)</a>',
+            f'<a href="{csv_import_url}"><span class="mdi mdi-database-import text-secondary" aria-hidden="true"></span> Import from CSV (multiple records)</a>',
             content,
         )
 
@@ -1321,11 +1322,11 @@ class ModuleTypeTestCase(
         )
         self.assertInHTML('<input type="hidden" name="export_format" value="yaml">', content)
         self.assertInHTML(
-            '<button type="submit"><span class="mdi mdi-database-export text-muted" aria-hidden="true"></span> Export as YAML</button>',
+            '<button type="submit"><span class="mdi mdi-database-export text-secondary" aria-hidden="true"></span> Export as YAML</button>',
             content,
         )
         self.assertInHTML(
-            '<button type="submit"><span class="mdi mdi-database-export text-muted" aria-hidden="true"></span> Export as CSV</button>',
+            '<button type="submit"><span class="mdi mdi-database-export text-secondary" aria-hidden="true"></span> Export as CSV</button>',
             content,
         )
 
@@ -2310,7 +2311,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "status": statuses[1].pk,
             "primary_ip4": None,
             "primary_ip6": None,
-            "cluster": None,
+            "clusters": [cluster.pk],
             "secrets_group": secrets_groups[1].pk,
             "virtual_chassis": None,
             "vc_position": None,
@@ -2333,7 +2334,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "status": statuses[2].pk,
             "location": locations[1].pk,
             "rack": racks[1].pk,
-            "cluster": cluster.pk,
+            "add_clusters": [cluster.pk],
             "comments": "An older device",
             "position": None,
             "face": DeviceFaceChoices.FACE_FRONT,
@@ -2354,7 +2355,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         add_vdc_url = reverse("dcim:virtualdevicecontext_add")
         return_url = device.get_absolute_url()
         expected_add_vdc_button_html = f"""
-        <a href="{add_vdc_url}?device={device.id}&amp;return_url={return_url}" class="btn btn-primary btn-xs">
+        <a href="{add_vdc_url}?device={device.id}&amp;return_url={return_url}" class="btn btn-primary btn-sm">
             <span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add virtual device context
         </a>
         """
@@ -2512,7 +2513,7 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             self.assertEqual(self.interfaces[0].ip_addresses.all().count(), 0)
 
         with self.subTest("Assert Cannot assign IPAddress(Existing IP) without permission"):
-            # Assert Assign Exsisting IPAddress
+            # Assert Assign Existing IPAddress
             response = self.client.post(**assign_ip_request, follow=True)
             self.assertBodyContains(response, f"Interface with id &quot;{self.interfaces[1].pk}&quot; not found")
             self.interfaces[1].refresh_from_db()
@@ -2626,6 +2627,15 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         response = self.client.get(url)
         self.assertHttpStatus(response, 200)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_device_vpnendpoints(self):
+        self.add_permissions("vpn.view_vpntunnelendpoint")
+        device = Device.objects.first()
+
+        url = reverse("dcim:device_vpnendpoints", kwargs={"pk": device.pk})
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_device_napalm_tabs(self):
         self.add_permissions("dcim.napalm_read_device")
@@ -2898,7 +2908,7 @@ class ModuleTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             self.assertEqual(self.interfaces[0].ip_addresses.all().count(), 0)
 
         with self.subTest("Assert Cannot assign IPAddress(Existing IP) without permission"):
-            # Assert Assign Exsisting IPAddress
+            # Assert Assign Existing IPAddress
             response = self.client.post(**assign_ip_request, follow=True)
             self.assertBodyContains(response, f"Interface with id &quot;{self.interfaces[1].pk}&quot; not found")
             self.interfaces[1].refresh_from_db()
@@ -4331,7 +4341,7 @@ class VirtualChassisTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         Interface.objects.create(device=self.devices[2], name="device 2 interface 1", status=interface_status)
         Interface.objects.create(device=self.devices[2], name="device 2 interface 2", status=interface_status)
         response = self.client.get(reverse("dcim:device_interfaces", kwargs={"pk": self.devices[0].pk}))
-        self.assertBodyContains(response, 'Interfaces <span class="badge">6</span>')
+        self.assertBodyContains(response, 'Interfaces <span class="badge bg-primary">6</span>')
         self.assertBodyContains(response, "device 1 interface 1")
         self.assertBodyContains(response, "device 1 interface 2")
         self.assertBodyContains(response, "device 2 interface 1")
@@ -4582,7 +4592,8 @@ class PathTraceViewTestCase(ModelViewTestCase):
         url = reverse("dcim:rearport_trace", args=[obj.pk])
         cablepath_id = CablePath.objects.first().id
         response = self.client.get(url + f"?cablepath_id={cablepath_id}")
-        self.assertBodyContains(response, "<h1>Cable Trace for Rear Port Rear Port 1</h1>", html=True)
+        self.assertBodyContains(response, "Rear Port 1")
+        self.assertBodyContains(response, "eth0")
 
 
 class DeviceRedundancyGroupTestCase(ViewTestCases.PrimaryObjectViewTestCase):

nautobot/dcim/utils.py

@@ -49,9 +49,9 @@ def cable_status_color_css(record):
         return ""
     else:
         CABLE_STATUS_TO_CSS_CLASS = {
-            ColorChoices.COLOR_GREEN: "success",
-            ColorChoices.COLOR_AMBER: "warning",
-            ColorChoices.COLOR_CYAN: "info",
+            ColorChoices.COLOR_GREEN: "table-success",
+            ColorChoices.COLOR_AMBER: "table-warning",
+            ColorChoices.COLOR_CYAN: "table-info",
         }
         status_color = record.cable.get_status_color().strip("#")
         return CABLE_STATUS_TO_CSS_CLASS.get(status_color, "")