nautobot 2.4.13__py3-none-any.whl → 2.4.15__py3-none-any.whl

nautobot/dcim/tests/test_filters.py

@@ -14,10 +14,12 @@ from nautobot.dcim.choices import (
     InterfaceModeChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
+    PowerFeedBreakerPoleChoices,
     PowerFeedPhaseChoices,
     PowerFeedSupplyChoices,
     PowerFeedTypeChoices,
     PowerOutletFeedLegChoices,
+    PowerPathChoices,
     RackDimensionUnitChoices,
     RackTypeChoices,
     RackWidthChoices,
@@ -120,6 +122,7 @@ from nautobot.dcim.models import (
     VirtualChassis,
     VirtualDeviceContext,
 )
+from nautobot.extras.filters.mixins import RoleFilter, StatusFilter
 from nautobot.extras.models import ExternalIntegration, Role, SecretsGroup, Status, Tag
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, Service, VLAN, VLANGroup
 from nautobot.tenancy.models import Tenant
@@ -230,6 +233,7 @@ def common_test_data(cls):
         PowerPanel.objects.create(name="Power Panel 1", location=loc0, rack_group=rack_groups[0]),
         PowerPanel.objects.create(name="Power Panel 2", location=loc1, rack_group=rack_groups[1]),
         PowerPanel.objects.create(name="Power Panel 3", location=loc1, rack_group=rack_groups[2]),
+        PowerPanel.objects.create(name="Power Panel 4", location=loc0),
     )
     power_panels[0].tags.set(Tag.objects.get_for_model(PowerPanel))
     power_panels[1].tags.set(Tag.objects.get_for_model(PowerPanel)[:3])
@@ -350,7 +354,19 @@ def common_test_data(cls):
     power_feeds = (
         PowerFeed.objects.create(name="Power Feed 1", rack=racks[0], power_panel=power_panels[0], status=pf_status),
         PowerFeed.objects.create(name="Power Feed 2", rack=racks[1], power_panel=power_panels[1], status=pf_status),
-        PowerFeed.objects.create(name="Power Feed 3", rack=racks[2], power_panel=power_panels[2], status=pf_status),
+        PowerFeed.objects.create(
+            name="Power Feed 3",
+            rack=racks[2],
+            power_panel=power_panels[2],
+            status=pf_status,
+            destination_panel=power_panels[0],
+        ),
+        PowerFeed.objects.create(
+            name="Power Feed 4",
+            power_panel=power_panels[1],
+            status=pf_status,
+            destination_panel=power_panels[3],
+        ),
     )
     power_feeds[0].tags.set(Tag.objects.get_for_model(PowerFeed))
     power_feeds[1].tags.set(Tag.objects.get_for_model(PowerFeed)[:3])
@@ -696,42 +712,42 @@ def common_test_data(cls):
     # Create 3 of each component template on the first two module types
     for i in range(6):
         ConsolePortTemplate.objects.create(
-            name=f"Test Filters Module Console Port {i+1}",
+            name=f"Test Filters Module Console Port {i + 1}",
             module_type=module_types[i % 2],
         )
         ConsoleServerPortTemplate.objects.create(
-            name=f"Test Filters Module Console Server Port {i+1}",
+            name=f"Test Filters Module Console Server Port {i + 1}",
             module_type=module_types[i % 2],
         )
         ppt = PowerPortTemplate.objects.create(
-            name=f"Test Filters Module Power Port {i+1}",
+            name=f"Test Filters Module Power Port {i + 1}",
             module_type=module_types[i % 2],
         )
         PowerOutletTemplate.objects.create(
-            name=f"Test Filters Module Power Outlet {i+1}",
+            name=f"Test Filters Module Power Outlet {i + 1}",
             power_port_template=ppt,
             module_type=module_types[i % 2],
         )
         InterfaceTemplate.objects.create(
-            name=f"Test Filters Module Interface {i+1}",
+            name=f"Test Filters Module Interface {i + 1}",
             type=InterfaceTypeChoices.TYPE_1GE_FIXED,
             module_type=module_types[i % 2],
         )
         rpt = RearPortTemplate.objects.create(
-            name=f"Test Filters Module Rear Port {i+1}",
+            name=f"Test Filters Module Rear Port {i + 1}",
             module_type=module_types[i % 2],
             type=PortTypeChoices.TYPE_8P8C,
             positions=10,
         )
         FrontPortTemplate.objects.create(
-            name=f"Test Filters Module Front Port {i+1}",
+            name=f"Test Filters Module Front Port {i + 1}",
             module_type=module_types[i % 2],
             rear_port_template=rpt,
             rear_port_position=i + 1,
             type=PortTypeChoices.TYPE_8P8C,
         )
         ModuleBayTemplate.objects.create(
-            name=f"Test Filters Module Module Bay {i+1}",
+            name=f"Test Filters Module Module Bay {i + 1}",
             position=i + 1,
             module_type=module_types[i % 2],
             requires_first_party_modules=(i % 2 == 0),  # True for even indices, False for odd
@@ -1253,7 +1269,7 @@ class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
 
         rack_group = RackGroup.objects.get(name="Rack Group 3")
         tenant = Tenant.objects.filter(tenant_group__isnull=False).first()
-        rack_role = Role.objects.get_for_model(Rack).first()
+        cls.rack_role = Role.objects.get_for_model(Rack).first()
 
         Rack.objects.create(
             name="Rack 4",
@@ -1262,7 +1278,7 @@ class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
             rack_group=rack_group,
             tenant=tenant,
             status=cls.rack_statuses[0],
-            role=rack_role,
+            role=cls.rack_role,
             serial="ABCDEF",
             asset_tag="1004",
             type=RackTypeChoices.TYPE_2POST,
@@ -1291,6 +1307,34 @@ class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
             params = {"outer_unit": [RackDimensionUnitChoices.UNIT_MILLIMETER]}
             self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
+    def test_role_status_negation(self):
+        """https://github.com/nautobot/nautobot/issues/6456"""
+        self.assertIsInstance(self.filterset().filters["role"], RoleFilter)
+        self.assertIsInstance(self.filterset().filters["role__n"], RoleFilter)
+        with self.subTest("Negated role (id)"):
+            params = {"role__n": [self.rack_role.pk]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs, Rack.objects.exclude(role=self.rack_role)
+            )
+        with self.subTest("Negated role (name)"):
+            params = {"role__n": [self.rack_role.name]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs, Rack.objects.exclude(role=self.rack_role)
+            )
+
+        self.assertIsInstance(self.filterset().filters["status"], StatusFilter)
+        self.assertIsInstance(self.filterset().filters["status__n"], StatusFilter)
+        with self.subTest("Negated status (id)"):
+            params = {"status__n": [self.rack_statuses[0].pk]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs, Rack.objects.exclude(status=self.rack_statuses[0])
+            )
+        with self.subTest("Negated status (name)"):
+            params = {"status__n": [self.rack_statuses[0].name]}
+            self.assertQuerysetEqualAndNotEmpty(
+                self.filterset(params, self.queryset).qs, Rack.objects.exclude(status=self.rack_statuses[0])
+            )
+
 
 class RackReservationTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RackReservation.objects.all()
@@ -3559,8 +3603,6 @@ class PowerPanelTestCase(FilterTestCases.FilterTestCase):
     def setUpTestData(cls):
         common_test_data(cls)
 
-        PowerPanel.objects.create(name="Power Panel 4", location=cls.loc1)
-
 
 class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCase):
     queryset = PowerFeed.objects.all()
@@ -3568,8 +3610,12 @@ class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCa
     generic_filter_tests = [
         ("amperage",),
         ("available_power",),
+        ("breaker_pole_count",),
+        ("breaker_position",),
         ("cable", "cable__id"),
         ("comments",),
+        ("destination_panel", "destination_panel__id"),
+        ("destination_panel", "destination_panel__name"),
         ("max_utilization",),
         ("name",),
         ("power_panel", "power_panel__id"),
@@ -3589,6 +3635,7 @@ class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCa
             PowerFeed.objects.get(name="Power Feed 1"),
             PowerFeed.objects.get(name="Power Feed 2"),
             PowerFeed.objects.get(name="Power Feed 3"),
+            PowerFeed.objects.get(name="Power Feed 4"),
         )
 
         pf_statuses = Status.objects.get_for_model(PowerFeed)
@@ -3602,6 +3649,9 @@ class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCa
             amperage=100,
             max_utilization=10,
             comments="PFA",
+            power_path=PowerPathChoices.PATH_A,
+            breaker_position=1,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_1,
         )
         PowerFeed.objects.filter(pk=power_feeds[1].pk).update(
             status=pf_statuses[1],
@@ -3612,6 +3662,9 @@ class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCa
             amperage=200,
             max_utilization=20,
             comments="PFB",
+            power_path=PowerPathChoices.PATH_B,
+            breaker_position=4,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_2,
         )
         PowerFeed.objects.filter(pk=power_feeds[2].pk).update(
             status=pf_statuses[2],
@@ -3622,14 +3675,32 @@ class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCa
             amperage=300,
             max_utilization=30,
             comments="PFC",
+            power_path=PowerPathChoices.PATH_A,
+            breaker_position=9,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_3,
+        )
+        PowerFeed.objects.filter(pk=power_feeds[3].pk).update(
+            status=pf_statuses[0],
+            type=PowerFeedTypeChoices.TYPE_REDUNDANT,
+            supply=PowerFeedSupplyChoices.SUPPLY_AC,
+            phase=PowerFeedPhaseChoices.PHASE_3PHASE,
+            voltage=400,
+            amperage=400,
+            max_utilization=40,
+            comments="PFD",
+            power_path=PowerPathChoices.PATH_B,
+            breaker_position=15,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_2,
         )
 
         power_feeds[0].refresh_from_db()
         power_feeds[1].refresh_from_db()
         power_feeds[2].refresh_from_db()
+        power_feeds[3].refresh_from_db()
         power_feeds[0].validated_save()
         power_feeds[1].validated_save()
         power_feeds[2].validated_save()
+        power_feeds[3].validated_save()
 
         power_ports = (
             PowerPort.objects.get(name="Power Port 1"),
@@ -3674,6 +3745,13 @@ class PowerFeedTestCase(PathEndpointModelTestMixin, FilterTestCases.FilterTestCa
             self.queryset.filter(phase=PowerFeedPhaseChoices.PHASE_3PHASE),
         )
 
+    def test_power_path(self):
+        params = {"power_path": [PowerPathChoices.PATH_A]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(power_path=PowerPathChoices.PATH_A),
+        )
+
 
 class DeviceRedundancyGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = DeviceRedundancyGroup.objects.all()

nautobot/dcim/tests/test_models.py

@@ -19,6 +19,10 @@ from nautobot.dcim.choices import (
     InterfaceModeChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
+    PowerFeedBreakerPoleChoices,
+    PowerFeedPhaseChoices,
+    PowerFeedSupplyChoices,
+    PowerFeedTypeChoices,
     PowerOutletFeedLegChoices,
     PowerOutletTypeChoices,
     PowerPortTypeChoices,
@@ -53,6 +57,7 @@ from nautobot.dcim.models import (
     ModuleFamily,
     ModuleType,
     Platform,
+    PowerFeed,
     PowerOutlet,
     PowerOutletTemplate,
     PowerPanel,
@@ -2389,6 +2394,263 @@ class CableTestCase(ModelTestCases.BaseModelTestCase):
             self.device1.delete()
 
 
+class PowerFeedTestCase(ModelTestCases.BaseModelTestCase):
+    model = PowerFeed
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        cls.status = Status.objects.get_for_model(PowerFeed).first()
+        cls.rack_status = Status.objects.get_for_model(Rack).first()
+
+        cls.source_panel = PowerPanel.objects.create(location=cls.location, name="Source Panel 1")
+        cls.destination_panel = PowerPanel.objects.create(location=cls.location, name="Destination Panel 1")
+
+        # Create location in different hierarchy for rack validation test
+        cls.other_location = Location.objects.create(
+            name="Other Location",
+            location_type=LocationType.objects.get(name="Campus"),
+            status=Status.objects.get_for_model(Location).first(),
+        )
+
+        cls.rack = Rack.objects.create(location=cls.location, name="Test Rack", status=cls.rack_status)
+        cls.other_rack = Rack.objects.create(location=cls.other_location, name="Other Rack", status=cls.rack_status)
+
+        PowerFeed.objects.create(
+            name="Test Power Feed 1",
+            power_panel=cls.source_panel,
+            rack=cls.rack,
+            status=cls.status,
+        )
+        PowerFeed.objects.create(
+            name="Test Power Feed 2",
+            power_panel=cls.source_panel,
+            status=cls.status,
+        )
+        PowerFeed.objects.create(
+            name="Test Power Feed 3",
+            power_panel=cls.destination_panel,
+            status=cls.status,
+        )
+
+    def test_destination_panel_self_reference_validation(self):
+        """Test that a power feed cannot reference itself."""
+        feed = PowerFeed(
+            name="Self Reference",
+            power_panel=self.source_panel,
+            destination_panel=self.source_panel,
+            status=self.status,
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            feed.full_clean()
+        self.assertIn("destination_panel", cm.exception.message_dict)
+
+    def test_circuit_breaker_position_conflict_validation(self):
+        """Test that overlapping circuit breaker positions raise validation errors."""
+        # Create first feed at position 1 with 2 poles (occupies 1,3)
+        PowerFeed.objects.create(
+            name="Feed 1",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=1,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_2,
+        )
+
+        # Try to create conflicting feed at position 3
+        conflicting_feed = PowerFeed(
+            name="Feed 2",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=3,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_1,
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            conflicting_feed.full_clean()
+        self.assertIn("breaker_position", cm.exception.message_dict)
+
+    def test_rack_location_hierarchy_validation(self):
+        """Test that rack must belong to same location hierarchy as power panel."""
+        feed = PowerFeed(
+            name="Invalid Rack Location",
+            power_panel=self.source_panel,
+            rack=self.other_rack,  # Different location hierarchy
+            status=self.status,
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            feed.full_clean()
+        self.assertIn("rack", cm.exception.message_dict)
+
+    def test_ac_voltage_negative_validation(self):
+        """Test that AC supply cannot have negative voltage."""
+        feed = PowerFeed(
+            name="Negative Voltage",
+            power_panel=self.source_panel,
+            status=self.status,
+            voltage=-120,
+            supply=PowerFeedSupplyChoices.SUPPLY_AC,
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            feed.full_clean()
+        self.assertIn("voltage", cm.exception.message_dict)
+
+    def test_phase_designation_single_pole(self):
+        """Test phase designation calculation for single-pole breakers."""
+        # Pattern: positions 1,2=A, 3,4=B, 5,6=C, 7,8=A, etc.
+        test_cases = [
+            (1, "A"),
+            (2, "A"),
+            (3, "B"),
+            (4, "B"),
+            (5, "C"),
+            (6, "C"),
+            (7, "A"),
+            (8, "A"),
+            (9, "B"),
+            (10, "B"),
+        ]
+
+        for position, expected_phase in test_cases:
+            with self.subTest(position=position):
+                feed = PowerFeed.objects.create(
+                    name=f"1P Test {position}",
+                    power_panel=self.source_panel,
+                    status=self.status,
+                    breaker_position=position,
+                    breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_1,
+                    # phase defaults to PHASE_SINGLE which is correct for all single-pole feeds
+                )
+                self.assertEqual(feed.phase_designation, expected_phase)
+
+    def test_phase_designation_two_pole_single_phase(self):
+        """Test phase designation for 2-pole breakers delivering single-phase power."""
+        # Common datacenter scenario: 2P breaker for 208V single-phase to rack PDU
+        # Uses two phase conductors but delivers single-phase power
+        test_cases = [
+            (1, "A-B"),  # occupies 1,3 → A,B → 208V single-phase
+            (2, "A-B"),  # occupies 2,4 → A,B → 208V single-phase
+            (3, "B-C"),  # occupies 3,5 → B,C → 208V single-phase
+            (4, "B-C"),  # occupies 4,6 → B,C → 208V single-phase
+            (5, "A-C"),  # occupies 5,7 → C,A → sorted to A-C → 208V single-phase
+            (6, "A-C"),  # occupies 6,8 → C,A → sorted to A-C → 208V single-phase
+            (7, "A-B"),  # occupies 7,9 → A,B → 208V single-phase (cycle continues)
+        ]
+
+        for position, expected_designation in test_cases:
+            with self.subTest(position=position):
+                feed = PowerFeed.objects.create(
+                    name=f"2P Single-Phase Test {position}",
+                    power_panel=self.source_panel,
+                    status=self.status,
+                    breaker_position=position,
+                    breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_2,
+                    # phase defaults to PHASE_SINGLE - correct for 208V single-phase feeds
+                )
+                self.assertEqual(feed.phase_designation, expected_designation)
+                # Verify it's still marked as single-phase power
+                self.assertEqual(feed.phase, PowerFeedPhaseChoices.PHASE_SINGLE)
+
+    def test_phase_designation_three_pole_three_phase(self):
+        """Test phase designation for 3-pole breakers delivering three-phase power."""
+        # True three-phase power using all three phases
+        test_cases = [1, 2, 3, 4, 5]
+
+        for position in test_cases:
+            with self.subTest(position=position):
+                feed = PowerFeed.objects.create(
+                    name=f"3P Three-Phase Test {position}",
+                    power_panel=self.source_panel,
+                    status=self.status,
+                    breaker_position=position,
+                    breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_3,
+                    phase=PowerFeedPhaseChoices.PHASE_3PHASE,  # Explicitly set to three-phase
+                )
+                self.assertEqual(feed.phase_designation, "A-B-C")
+                # Verify it's marked as three-phase power
+                self.assertEqual(feed.phase, PowerFeedPhaseChoices.PHASE_3PHASE)
+
+    def test_phase_designation_edge_cases(self):
+        """Test phase designation calculation for edge cases and None values."""
+        # Test missing breaker_position
+        feed = PowerFeed.objects.create(
+            name="No Position",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=None,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_1,
+        )
+        self.assertIsNone(feed.phase_designation)
+
+        # Test missing breaker_pole_count (should default to single pole)
+        feed = PowerFeed.objects.create(
+            name="No Pole Count",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=1,
+            breaker_pole_count=None,
+        )
+        # Should default to single pole and have phase designation
+        self.assertEqual(feed.breaker_pole_count, PowerFeedBreakerPoleChoices.POLE_1)
+        self.assertEqual(feed.phase_designation, "A")
+
+        # Test both missing
+        feed = PowerFeed.objects.create(
+            name="No Position or Pole Count",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=None,
+            breaker_pole_count=None,
+        )
+        self.assertIsNone(feed.phase_designation)
+
+    def test_phase_field_defaults(self):
+        """Test that phase field defaults correctly and type field defaults to primary."""
+        feed = PowerFeed.objects.create(
+            name="Default Fields Test",
+            power_panel=self.source_panel,
+            status=self.status,
+        )
+
+        # Verify defaults
+        self.assertEqual(feed.phase, PowerFeedPhaseChoices.PHASE_SINGLE)
+        self.assertEqual(feed.type, PowerFeedTypeChoices.TYPE_PRIMARY)
+
+    def test_occupied_positions(self):
+        """Test occupied positions calculation."""
+        feed = PowerFeed.objects.create(
+            name="Test Feed",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=5,
+            breaker_pole_count=PowerFeedBreakerPoleChoices.POLE_2,
+        )
+
+        self.assertEqual(feed.get_occupied_positions(), {5, 7})
+        self.assertEqual(feed.occupied_positions, "5, 7")
+
+    def test_breaker_pole_count_enforcement_in_save(self):
+        """Test that breaker_pole_count defaults to POLE_1 when breaker_position is set during save."""
+        # Create feed with breaker_position but no breaker_pole_count
+        feed = PowerFeed(
+            name="Test Save Enforcement",
+            power_panel=self.source_panel,
+            status=self.status,
+            breaker_position=10,
+        )
+
+        # Verify breaker_pole_count is None before save
+        self.assertIsNone(feed.breaker_pole_count)
+
+        # Save without calling clean() to bypass form validation
+        feed.save()
+
+        # Verify breaker_pole_count was set to POLE_1 during save
+        self.assertEqual(feed.breaker_pole_count, PowerFeedBreakerPoleChoices.POLE_1)
+
+
 class PowerPanelTestCase(TestCase):  # TODO: change to BaseModelTestCase once we have a PowerPanelFactory
     def test_power_panel_validation(self):
         status = Status.objects.get_for_model(Location).first()

nautobot/dcim/tests/test_views.py

@@ -715,32 +715,33 @@ class RackTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         # Test the view
         response = self.client.get(reverse("dcim:rack", args=[self.racks[0].pk]))
         self.assertHttpStatus(response, 200)
+
         # Validate Power Utilization for PowerFeed 11 is displaying correctly on Rack View.
         power_feed_11_html = """
-        <td><div title="Used: 1200&#13;Count: 3840" class="progress text-center">
+        <td><div title="Used: 1263&#13;Count: 3840" class="progress text-center">
             <div class="progress-bar progress-bar-success"
-                role="progressbar" aria-valuenow="31" aria-valuemin="0" aria-valuemax="100" style="width: 31%">
-                31%
+                role="progressbar" aria-valuenow="32" aria-valuemin="0" aria-valuemax="100" style="width: 32%">
+                32%
             </div>
         </div></td>
         """
         self.assertContains(response, power_feed_11_html, html=True)
         # Validate Power Utilization for PowerFeed12 is displaying correctly on Rack View.
         power_feed_12_html = """
-        <td><div title="Used: 2400&#13;Count: 3840" class="progress text-center">
+        <td><div title="Used: 2526&#13;Count: 3840" class="progress text-center">
             <div class="progress-bar progress-bar-success"
-                role="progressbar" aria-valuenow="62" aria-valuemin="0" aria-valuemax="100" style="width: 62%">
-                62%
+                role="progressbar" aria-valuenow="65" aria-valuemin="0" aria-valuemax="100" style="width: 65%">
+                65%
             </div>
         </div></td>
         """
         self.assertContains(response, power_feed_12_html, html=True)
         # Validate Rack Power Utilization for Combined powerfeeds is displaying correctly on the Rack View
         total_utilization_html = """
-        <td><div title="Used: 3600&#13;Count: 7680" class="progress text-center">
+        <td><div title="Used: 3789&#13;Count: 7680" class="progress text-center">
             <div class="progress-bar progress-bar-success"
-                role="progressbar" aria-valuenow="46" aria-valuemin="0" aria-valuemax="100" style="width: 46%">
-                46%
+                role="progressbar" aria-valuenow="49" aria-valuemin="0" aria-valuemax="100" style="width: 49%">
+                49%
             </div>
         </div></td>
         """
@@ -1656,6 +1657,7 @@ class PowerPortTemplateTestCase(ViewTestCases.DeviceComponentTemplateViewTestCas
             "type": PowerPortTypeChoices.TYPE_IEC_C14,
             "maximum_draw": 100,
             "allocated_draw": 50,
+            "power_factor": Decimal("0.95"),
         }
 
         cls.bulk_create_data = {
@@ -1665,6 +1667,7 @@ class PowerPortTemplateTestCase(ViewTestCases.DeviceComponentTemplateViewTestCas
             "type": PowerPortTypeChoices.TYPE_IEC_C14,
             "maximum_draw": 100,
             "allocated_draw": 50,
+            "power_factor": Decimal("0.95"),
         }
 
         cls.bulk_edit_data = {
@@ -1678,6 +1681,7 @@ class PowerPortTemplateTestCase(ViewTestCases.DeviceComponentTemplateViewTestCas
             "name": test_instance.name,
             "device_type": getattr(getattr(test_instance, "device_type", None), "pk", None),
             "module_type": getattr(getattr(test_instance, "module_type", None), "pk", None),
+            "power_factor": Decimal("0.95"),
             "label": "new test label",
             "description": "new test description",
         }
@@ -2134,8 +2138,9 @@ class DeviceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         devicetypes[0].software_image_files.set(software_image_files[:2])
         devicetypes[1].software_image_files.set(software_image_files[2:])
         # Only valid software image files are those that belong to the device type or default images
-        valid_software_image_files = software_image_files[2:] + [
-            SoftwareImageFile.objects.filter(default_image=True).first()
+        valid_software_image_files = [
+            *software_image_files[2:],
+            SoftwareImageFile.objects.filter(default_image=True).first(),
         ]
 
         cls.custom_fields = (
@@ -2885,16 +2890,18 @@ class PowerPortTestCase(ViewTestCases.DeviceComponentViewTestCase):
             "type": PowerPortTypeChoices.TYPE_IEC_C14,
             "maximum_draw": 100,
             "allocated_draw": 50,
+            "power_factor": Decimal("0.95"),
             "description": "A power port",
             "tags": [t.pk for t in Tag.objects.get_for_model(PowerPort)],
         }
 
         cls.bulk_create_data = {
             "device": device.pk,
-            "name_pattern": "Power Port [4-6]]",
+            "name_pattern": "Power Port [4-6]",
             "type": PowerPortTypeChoices.TYPE_IEC_C14,
             "maximum_draw": 100,
             "allocated_draw": 50,
+            "power_factor": Decimal("0.95"),
             "description": "A power port",
             "tags": [t.pk for t in Tag.objects.get_for_model(PowerPort)],
         }
@@ -2911,6 +2918,7 @@ class PowerPortTestCase(ViewTestCases.DeviceComponentViewTestCase):
             "name": test_instance.name,
             "device": getattr(getattr(test_instance, "device", None), "pk", None),
             "module": getattr(getattr(test_instance, "module", None), "pk", None),
+            "power_factor": Decimal("0.95"),
             "label": "new test label",
             "description": "new test description",
         }