test(drivers): cover boot vs real port interface-type selection

Locks in the create_machine()/attach_port() behavior fixed in the
previous commit: the boot-network port always gets type='network' on
a bridge-type hypervisor, while any other port (attach_port(), and
create_machine()'s post-flash recreate_machine() path) keeps honoring
network_type - matching what real bridge-type hypervisors actually run
(raw bridge-type interfaces), per PR #527 review feedback.

Author: VasilyStepanov

exordos_core/tests/unit/compute/pool/drivers/test_libvirt.py

@@ -26,23 +26,55 @@
 # collection when they're not available.
 pytest.importorskip("libvirt")
 
+from exordos_core.compute import constants as nc  # noqa: E402
 from exordos_core.compute.dm import models  # noqa: E402
 from exordos_core.compute.pool.drivers.libvirt import LibvirtPoolDriver  # noqa: E402
 from exordos_core.compute.pool.drivers.libvirt import XMLLibvirtInstance  # noqa: E402
 from exordos_core.compute.pool.drivers.libvirt import domain_template  # noqa: E402
 
 
-def _local_driver() -> LibvirtPoolDriver:
+def _local_driver(network_type: str = "network") -> LibvirtPoolDriver:
     # libvirt's built-in "test" driver simulates a hypervisor in-memory -
     # no real virtualization or daemon needed, so real libvirt calls
-    # (lookupByUUIDString, etc.) can be exercised end-to-end.
-    spec = models.LibvirtPoolDriverSpec(connection_uri="test:///default")
+    # (lookupByUUIDString, etc.) can be exercised end-to-end. It even ships
+    # a default storage pool ("default-pool"), so create_machine() can be
+    # exercised end-to-end too.
+    spec = models.LibvirtPoolDriverSpec(
+        connection_uri="test:///default",
+        network_type=network_type,
+        storage_pool="default-pool",
+    )
     pool = models.MachinePool(
         uuid=sys_uuid.uuid4(), name="test-pool", driver_spec=spec
     )
     return LibvirtPoolDriver(pool)
 
 
+def _machine() -> models.Machine:
+    return models.Machine(
+        uuid=sys_uuid.uuid4(),
+        project_id=sys_uuid.uuid4(),
+        name="test-vm",
+        cores=1,
+        ram=512,
+    )
+
+
+def _port(uuid: sys_uuid.UUID, source: str) -> models.Port:
+    return models.Port(
+        uuid=uuid,
+        project_id=sys_uuid.uuid4(),
+        mac=models.Port.generate_mac(),
+        source=source,
+        status=nc.PortStatus.ACTIVE.value,
+    )
+
+
+def _live_interface(driver: LibvirtPoolDriver, machine: models.Machine) -> ET.Element:
+    domain = driver._client.lookupByUUIDString(str(machine.uuid))
+    return ET.fromstring(domain.XMLDesc()).find(".//devices/interface")
+
+
 def test_domain_console_logs_to_file():
     log_path = "/var/log/libvirt/qemu/test-vm.console.log"
 
@@ -137,3 +169,61 @@ def test_volume_cleanup_still_runs_when_the_domain_is_already_gone(self):
             driver.delete_machine(machine, delete_volumes=True)
 
         mock_list_volumes.assert_called_once_with(machine)
+
+
+class TestCreateMachine:
+    def test_boot_port_always_uses_network_type_on_a_bridge_hypervisor(self):
+        # Regression: a bridge-type hypervisor must not have the boot
+        # network's (logical, potentially long) name treated as a literal
+        # host bridge device name - libvirt rejects that outright as too
+        # long for IFNAMSIZ.
+        driver = _local_driver(network_type="bridge")
+        machine = _machine()
+        port = _port(nc.BOOT_NETWORK_PORT_UUID, source="exordos-core-boot-net")
+
+        driver.create_machine(machine, volumes=[], ports=[port])
+
+        interface = _live_interface(driver, machine)
+        assert interface.get("type") == "network"
+        assert interface.find("source").get("network") == "exordos-core-boot-net"
+
+    def test_real_port_honors_the_hypervisors_network_type(self):
+        # Regression: on a real bridge-type hypervisor, ports are raw
+        # bridge-type interfaces (source=<bridge device>) - not a libvirt
+        # network wrapping one. create_machine() is also used by
+        # recreate_machine() to rebuild the domain with the real port(s)
+        # post-flash, so it must not force type='network' on those.
+        driver = _local_driver(network_type="bridge")
+        machine = _machine()
+        port = _port(sys_uuid.uuid4(), source="br0")
+
+        driver.create_machine(machine, volumes=[], ports=[port])
+
+        interface = _live_interface(driver, machine)
+        assert interface.get("type") == "bridge"
+        assert interface.find("source").get("bridge") == "br0"
+
+
+class TestAttachPort:
+    def test_honors_the_hypervisors_network_type_for_bridge_hypervisors(self):
+        # Regression: attach_port() is only ever used for the real port,
+        # which on a bridge-type hypervisor is a raw bridge-type interface
+        # (source=<bridge device>) - not a libvirt network wrapping one.
+        #
+        # libvirt's test:// driver doesn't support attachDeviceFlags()'s
+        # LIVE+CONFIG flag combination, so mock the domain lookup instead
+        # of exercising a real domain end-to-end.
+        driver = _local_driver(network_type="bridge")
+        machine = _machine()
+        port = _port(sys_uuid.uuid4(), source="br0")
+
+        mock_domain = mock.MagicMock()
+        with mock.patch.object(
+            driver._client, "lookupByUUIDString", return_value=mock_domain
+        ):
+            driver.attach_port(machine, port)
+
+        interface_xml, _flags = mock_domain.attachDeviceFlags.call_args[0]
+        interface = ET.fromstring(interface_xml)
+        assert interface.get("type") == "bridge"
+        assert interface.find("source").get("bridge") == "br0"