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

nautobot/dcim/templates/dcim/powerfeed_retrieve.html

@@ -6,4 +6,4 @@
                 {% if object.rack %}
                     <li>{{ object.rack|hyperlinked_object }}</li>
                 {% endif %}
-{% endblock extra_breadcrumbs %}
+{% endblock extra_breadcrumbs %}

nautobot/dcim/tests/integration/test_device_bulk_operations.py

@@ -1,7 +1,13 @@
 import uuid
 
+from django.urls import reverse
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions
+from selenium.webdriver.support.ui import WebDriverWait
+
 from nautobot.core.testing.integration import (
     BulkOperationsTestCases,
+    SeleniumTestCase,
 )
 from nautobot.dcim.models import Device
 from nautobot.extras.tests.integration import create_test_device
@@ -28,3 +34,58 @@ class DeviceBulkOperationsTestCase(BulkOperationsTestCases.BulkOperationsTestCas
         create_test_device("Test Device Integration Test 3", test_uuid=test_uuid)
         create_test_device("Test Device Integration Test 4", "Test Location 2", test_uuid=test_uuid)
         create_test_device("Test Device Integration Test 5", "Test Location 2", test_uuid=test_uuid)
+
+
+class DeviceBulkUrlParamTestCase(SeleniumTestCase):
+    """
+    Integration test to check that when a bulk edit is initiated from a filtered device list view it does not fill in bulk edit form.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.user.is_superuser = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+        self.device1 = create_test_device("Device 1")
+
+    def tearDown(self):
+        self.logout()
+        super().tearDown()
+
+    def test_param_fills_device_type(self):
+        """
+        This test:
+         1 Go to device list page with param for device_type
+         2 Selects the row checkbox for the device with that device_type
+         3 Submits the bulk edit form
+         4 Checks that the device_type field is blank (i.e. "---------") on the bulk edit form
+        """
+
+        # Go to Device list page
+        self.browser.visit(
+            self.live_server_url + reverse("dcim:device_list") + f"?device_type={self.device1.device_type.pk}"
+        )
+
+        # 2) Check the row checkbox exactly matching the PK
+        pk = str(self.device1.pk)
+        cb_xpath = f'//input[@type="checkbox" and @name="pk" and @value="{pk}"]'
+        checkbox = WebDriverWait(self.browser.driver, 2).until(
+            expected_conditions.element_to_be_clickable((By.XPATH, cb_xpath))
+        )
+        self.browser.driver.execute_script("arguments[0].click();", checkbox)
+
+        # Click the bulk-edit button (it uses formaction)
+        bulk_url = reverse("dcim:device_bulk_edit")
+        btn_xpath = f'//button[@type="submit" and @formaction="{bulk_url}"]'
+        bulk_btn = WebDriverWait(self.browser.driver, 2).until(
+            expected_conditions.element_to_be_clickable((By.XPATH, btn_xpath))
+        )
+        # We know this works since if nothing is selected, you will be redirected back to the list view with a message
+        bulk_btn.click()
+
+        self.assertTrue(
+            WebDriverWait(self.browser.driver, 2).until(
+                lambda d: d.find_element(By.CLASS_NAME, "select2-selection__placeholder").text.strip() == "---------"
+            )
+        )

nautobot/dcim/tests/test_api.py

@@ -16,8 +16,10 @@ from nautobot.dcim.choices import (
     InterfaceModeChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
+    PowerFeedBreakerPoleChoices,
     PowerFeedTypeChoices,
     PowerOutletTypeChoices,
+    PowerPanelTypeChoices,
     PowerPortTypeChoices,
     SoftwareImageFileHashingAlgorithmChoices,
     SubdeviceRoleChoices,
@@ -3064,7 +3066,7 @@ class VirtualChassisTest(APIViewTestCases.APIViewTestCase):
                     # Interface name starts with parent device's position in VC; e.g. 1/1, 1/2, 1/3...
                     Interface.objects.create(
                         device=device,
-                        name=f"{i%3+1}/{j}",
+                        name=f"{i % 3 + 1}/{j}",
                         type=InterfaceTypeChoices.TYPE_1GE_FIXED,
                         status=interface_status,
                         role=interface_role,
@@ -3166,6 +3168,7 @@ class VirtualChassisTest(APIViewTestCases.APIViewTestCase):
 
 class PowerPanelTest(APIViewTestCases.APIViewTestCase):
     model = PowerPanel
+    choices_fields = ["panel_type", "power_path"]
 
     @classmethod
     def setUpTestData(cls):
@@ -3204,7 +3207,7 @@ class PowerPanelTest(APIViewTestCases.APIViewTestCase):
 
 class PowerFeedTest(APIViewTestCases.APIViewTestCase):
     model = PowerFeed
-    choices_fields = ["phase", "supply", "type"]
+    choices_fields = ["phase", "supply", "type", "breaker_pole_count", "power_path"]
 
     @classmethod
     def setUpTestData(cls):
@@ -3229,8 +3232,20 @@ class PowerFeedTest(APIViewTestCases.APIViewTestCase):
         )
 
         power_panels = (
-            PowerPanel.objects.create(location=location, rack_group=rackgroup, name="Power Panel 1"),
-            PowerPanel.objects.create(location=location, rack_group=rackgroup, name="Power Panel 2"),
+            PowerPanel.objects.create(
+                location=location,
+                rack_group=rackgroup,
+                name="Power Panel 1",
+                panel_type=PowerPanelTypeChoices.TYPE_UTILITY,
+                breaker_position_count=42,
+            ),
+            PowerPanel.objects.create(
+                location=location,
+                rack_group=rackgroup,
+                name="Power Panel 2",
+                panel_type=PowerPanelTypeChoices.TYPE_RPP,
+                breaker_position_count=24,
+            ),
         )
 
         PRIMARY = PowerFeedTypeChoices.TYPE_PRIMARY
@@ -3285,6 +3300,9 @@ class PowerFeedTest(APIViewTestCases.APIViewTestCase):
             {
                 "name": "Power Feed 4A",
                 "power_panel": power_panels[0].pk,
+                "destination_panel": power_panels[1].pk,
+                "breaker_position": 5,
+                "breaker_pole_count": PowerFeedBreakerPoleChoices.POLE_1,
                 "rack": racks[3].pk,
                 "status": statuses[0].pk,
                 "type": PRIMARY,
@@ -3292,6 +3310,8 @@ class PowerFeedTest(APIViewTestCases.APIViewTestCase):
             {
                 "name": "Power Feed 4B",
                 "power_panel": power_panels[1].pk,
+                "breaker_position": 10,
+                "breaker_pole_count": PowerFeedBreakerPoleChoices.POLE_2,
                 "rack": racks[3].pk,
                 "status": statuses[0].pk,
                 "type": REDUNDANT,

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()