diff options
Diffstat (limited to 'src/test/java/org/openslx/virtualization/configuration')
8 files changed, 1199 insertions, 0 deletions
diff --git a/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java new file mode 100644 index 0000000..1cc7841 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java @@ -0,0 +1,604 @@ +package org.openslx.virtualization.configuration; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +import org.apache.commons.io.FileUtils; +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.openslx.bwlp.thrift.iface.OperatingSystem; +import org.openslx.libvirt.domain.Domain; +import org.openslx.libvirt.domain.device.ControllerUsb; +import org.openslx.libvirt.domain.device.DiskCdrom; +import org.openslx.libvirt.domain.device.DiskFloppy; +import org.openslx.libvirt.domain.device.DiskStorage; +import org.openslx.libvirt.domain.device.Interface; +import org.openslx.libvirt.domain.device.Sound; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.Version; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.EtherType; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.EthernetDevType; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.SoundCardType; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.UsbSpeed; +import org.openslx.virtualization.configuration.logic.ConfigurationLogicTestUtils; +import org.openslx.vm.disk.DiskImage; +import org.openslx.vm.disk.DiskImageTestResources; +import org.openslx.vm.disk.DiskImage.ImageFormat; + +public class VirtualizationConfigurationQemuTest +{ + public static final List<OperatingSystem> STUB_OS_LIST = ConfigurationLogicTestUtils.STUB_OS_LIST; + + private static Domain getPrivateDomainFromQemuMetaData( VirtualizationConfigurationQemu qemuMetadata ) + throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException + { + Field privateDomainField = VirtualizationConfigurationQemu.class.getDeclaredField( "vmConfig" ); + privateDomainField.setAccessible( true ); + return Domain.class.cast( privateDomainField.get( qemuMetadata ) ); + } + + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test display name from VM configuration" ) + public void testQemuMetaDataGetDisplayName() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final String displayName = vmConfig.getDisplayName(); + + assertEquals( "archlinux", displayName ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @Test + @DisplayName( "Test machine snapshot state from VM configuration" ) + public void testQemuMetaDataIsMachineSnapshot() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final boolean isVmSnapshot = vmConfig.isMachineSnapshot(); + + assertEquals( false, isVmSnapshot ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @Test + @DisplayName( "Test supported image formats from VM configuration" ) + public void testQemuMetaDataGetSupportedImageFormats() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final List<DiskImage.ImageFormat> supportedImageFormats = vmConfig.getVirtualizer().getSupportedImageFormats(); + + assertNotNull( supportedImageFormats ); + assertEquals( 3, supportedImageFormats.size() ); + assertEquals( true, supportedImageFormats + .containsAll( Arrays.asList( ImageFormat.QCOW2, ImageFormat.VMDK, ImageFormat.VDI ) ) ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @Test + @DisplayName( "Test output of detected 32-bit OS from VM configuration" ) + public void testQemuMetaDataGetOs32Bit() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + final File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-ubuntu-20-04-vm_i686.xml" ); + final VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( + VirtualizationConfigurationQemuTest.STUB_OS_LIST, file ); + + final OperatingSystem os = vmConfig.getOs(); + + assertNotNull( os ); + assertEquals( VirtualizationConfigurationQemuTest.STUB_OS_LIST.get( 3 ), os ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @Test + @DisplayName( "Test output of detected 64-bit OS from VM configuration" ) + public void testQemuMetaDataGetOs64Bit() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + final File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + final VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( + VirtualizationConfigurationQemuTest.STUB_OS_LIST, file ); + + final OperatingSystem os = vmConfig.getOs(); + + assertNotNull( os ); + assertEquals( VirtualizationConfigurationQemuTest.STUB_OS_LIST.get( 4 ), os ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @Test + @DisplayName( "Test output of HDDs from VM configuration" ) + public void testQemuMetaDataGetHdds() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final List<VirtualizationConfiguration.HardDisk> hdds = vmConfig.getHdds(); + + assertNotNull( hdds ); + assertEquals( 1, hdds.size() ); + assertEquals( "/var/lib/libvirt/images/archlinux.qcow2", hdds.get( 0 ).diskImage ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @Test + @DisplayName( "Test output of unfiltered VM configuration" ) + public void testQemuMetaDataGetDefinitionArray() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final String unfilteredXmlConfig = new String( vmConfig.getConfigurationAsByteArray(), StandardCharsets.UTF_8 ); + final String originalXmlConfig = FileUtils.readFileToString( file, StandardCharsets.UTF_8 ); + + assertNotNull( unfilteredXmlConfig ); + + final int lengthUnfilteredXmlConfig = unfilteredXmlConfig.split( System.lineSeparator() ).length; + final int lengthOriginalXmlConfig = originalXmlConfig.split( System.lineSeparator() ).length; + + assertEquals( lengthOriginalXmlConfig, lengthUnfilteredXmlConfig ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test add HDD to VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-hdd.xml" } ) + public void testQemuMetaDataAddHdd( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" ); + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numHddsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskStorageDevices().size(); + final int numHddsQemuMetaDataBeforeAdd = vmConfig.getHdds().size(); + + vmConfig.addHddTemplate( diskFile, null, null ); + + final int numHddsLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getDiskStorageDevices().size(); + final int numHddsQemuMetaDataAfterAdd = vmConfig.getHdds().size(); + + assertTrue( numHddsLibvirtDomainXmlBeforeAdd == numHddsQemuMetaDataBeforeAdd ); + assertTrue( numHddsLibvirtDomainXmlAfterAdd == numHddsQemuMetaDataAfterAdd ); + assertTrue( numHddsQemuMetaDataBeforeAdd >= 0 ); + assertTrue( numHddsQemuMetaDataAfterAdd > 0 ); + + if ( numHddsQemuMetaDataBeforeAdd >= 1 ) { + // update existing HDD in the Libvirt XML config, but do not add a new HDD + assertEquals( numHddsQemuMetaDataBeforeAdd, numHddsQemuMetaDataAfterAdd ); + } else { + // numHddsQemuMetaDataBeforeAdd == 0 + // add a HDD to the Libvirt XML config, since there was no HDD available + assertEquals( numHddsQemuMetaDataBeforeAdd + 1, numHddsQemuMetaDataAfterAdd ); + } + + DiskStorage addedStorageDevice = vmLibvirtDomainConfig.getDiskStorageDevices().get( 0 ); + assertEquals( diskFile.getAbsolutePath(), addedStorageDevice.getStorageSource() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test add CDROM to VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-cdrom.xml" } ) + public void testQemuMetaDataAddCdrom( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" ); + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numCdromsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size(); + + vmConfig.addCdrom( 0, diskFile.getAbsolutePath() ); + + final int numCdromsLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size(); + + assertTrue( numCdromsLibvirtDomainXmlBeforeAdd >= 0 ); + assertTrue( numCdromsLibvirtDomainXmlAfterAdd > 0 ); + + DiskCdrom addedCdromDevice = vmLibvirtDomainConfig.getDiskCdromDevices().get( 0 ); + assertEquals( diskFile.getAbsolutePath(), addedCdromDevice.getStorageSource() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test add physical CDROM drive to VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-cdrom.xml" } ) + public void testQemuMetaDataAddPhysicalCdromDrive( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numCdromsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size(); + + vmConfig.addCdrom( 0, null ); + + final int numCdromsLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size(); + + assertTrue( numCdromsLibvirtDomainXmlBeforeAdd >= 0 ); + assertTrue( numCdromsLibvirtDomainXmlAfterAdd > 0 ); + + DiskCdrom addedCdromDevice = vmLibvirtDomainConfig.getDiskCdromDevices().get( 0 ); + assertEquals( VirtualizationConfigurationQemu.CDROM_DEFAULT_PHYSICAL_DRIVE, addedCdromDevice.getStorageSource() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test add floppy to VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-floppy.xml" } ) + public void testQemuMetaDataAddFloppy( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" ); + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numFloppiesLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskFloppyDevices().size(); + + vmConfig.addFloppy( 0, diskFile.getAbsolutePath(), true ); + + final int numFloppiesLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getDiskFloppyDevices().size(); + + assertTrue( numFloppiesLibvirtDomainXmlBeforeAdd >= 0 ); + assertTrue( numFloppiesLibvirtDomainXmlAfterAdd > 0 ); + + DiskFloppy addedFloppyDevice = vmLibvirtDomainConfig.getDiskFloppyDevices().get( 0 ); + assertTrue( addedFloppyDevice.isReadOnly() ); + assertEquals( diskFile.getAbsolutePath(), addedFloppyDevice.getStorageSource() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test add CPU core count to VM configuration" ) + @ValueSource( ints = { 2, 4, 6, 8 } ) + public void testQemuMetaDataAddCpuCoreCount( int coreCount ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + vmConfig.addCpuCoreCount( coreCount ); + + assertEquals( coreCount, vmLibvirtDomainConfig.getVCpu() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test get sound card from VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-sound.xml" } ) + public void testQemuMetaDataGetSoundCardType( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + SoundCardType soundCardType = vmConfig.getSoundCard(); + + if ( vmLibvirtDomainConfig.getSoundDevices().isEmpty() ) { + assertEquals( SoundCardType.NONE, soundCardType ); + } else { + assertEquals( SoundCardType.HD_AUDIO, soundCardType ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test set sound card in VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-sound.xml" } ) + public void testQemuMetaDataSetSoundCardType( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numSoundDevsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getSoundDevices().size(); + + vmConfig.setSoundCard( SoundCardType.SOUND_BLASTER ); + + final int numSoundDevsLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getSoundDevices().size(); + + assertTrue( numSoundDevsLibvirtDomainXmlBeforeAdd >= 0 ); + assertTrue( numSoundDevsLibvirtDomainXmlAfterAdd > 0 ); + + Sound addedSoundDevice = vmLibvirtDomainConfig.getSoundDevices().get( 0 ); + assertEquals( Sound.Model.SB16, addedSoundDevice.getModel() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test get ethernet device type from VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-nic.xml" } ) + public void testQemuMetaDataGetEthernetDevType( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + EthernetDevType ethernetDeviceType = vmConfig.getEthernetDevType( 0 ); + + if ( vmLibvirtDomainConfig.getInterfaceDevices().isEmpty() ) { + assertEquals( EthernetDevType.NONE, ethernetDeviceType ); + } else { + assertEquals( EthernetDevType.PARAVIRT, ethernetDeviceType ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test set ethernet device type in VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-nic.xml" } ) + public void testQemuMetaDataSetEthernetDevType( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + vmConfig.setEthernetDevType( 0, EthernetDevType.E1000E ); + + if ( !vmLibvirtDomainConfig.getInterfaceDevices().isEmpty() ) { + Interface addedEthernetDevice = vmLibvirtDomainConfig.getInterfaceDevices().get( 0 ); + assertEquals( Interface.Model.E1000E, addedEthernetDevice.getModel() ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test get maximal USB speed from VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-usb.xml" } ) + public void testQemuMetaDataGetMaxUsbSpeed( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + UsbSpeed maxUsbSpeed = vmConfig.getMaxUsbSpeed(); + + if ( vmLibvirtDomainConfig.getUsbControllerDevices().isEmpty() ) { + assertEquals( UsbSpeed.NONE, maxUsbSpeed ); + } else { + assertEquals( UsbSpeed.USB3_0, maxUsbSpeed ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test set maximal USB speed in VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-usb.xml" } ) + public void testQemuMetaDataSetMaxUsbSpeed( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numUsbControllersLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getUsbControllerDevices().size(); + + vmConfig.setMaxUsbSpeed( UsbSpeed.USB2_0 ); + + final int numUsbControllersLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getUsbControllerDevices().size(); + + assertTrue( numUsbControllersLibvirtDomainXmlBeforeAdd >= 0 ); + assertTrue( numUsbControllersLibvirtDomainXmlAfterAdd > 0 ); + + ControllerUsb addedUsbControllerDevice = vmLibvirtDomainConfig.getUsbControllerDevices().get( 0 ); + assertEquals( ControllerUsb.Model.ICH9_EHCI1, addedUsbControllerDevice.getModel() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + static Stream<Arguments> configAndEthernetTypeProvider() + { + return Stream.of( + arguments( "qemu-kvm_default-archlinux-vm.xml", EtherType.BRIDGED ), + arguments( "qemu-kvm_default-archlinux-vm.xml", EtherType.HOST_ONLY ), + arguments( "qemu-kvm_default-archlinux-vm.xml", EtherType.NAT ), + arguments( "qemu-kvm_default-archlinux-vm-no-usb.xml", EtherType.BRIDGED ), + arguments( "qemu-kvm_default-archlinux-vm-no-usb.xml", EtherType.HOST_ONLY ), + arguments( "qemu-kvm_default-archlinux-vm-no-usb.xml", EtherType.NAT ) ); + } + + @ParameterizedTest + @DisplayName( "Test add ethernet device to VM configuration" ) + @MethodSource( "configAndEthernetTypeProvider" ) + public void testQemuMetaDataAddEthernet( String xmlFileName, EtherType ethernetType ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final int numEthernetDevsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getInterfaceDevices().size(); + + vmConfig.addEthernet( ethernetType ); + + final int numEthernetDevsLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getInterfaceDevices().size(); + + assertTrue( numEthernetDevsLibvirtDomainXmlBeforeAdd >= 0 ); + assertTrue( numEthernetDevsLibvirtDomainXmlAfterAdd > 0 ); + + Interface addedEthernetDevice = vmLibvirtDomainConfig.getInterfaceDevices().get( 0 ); + switch ( ethernetType ) { + case BRIDGED: + assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() ); + assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() ); + assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_LAN_DEFAULT, addedEthernetDevice.getSource() ); + break; + case HOST_ONLY: + assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() ); + assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() ); + assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_HOST_ONLY_DEFAULT, + addedEthernetDevice.getSource() ); + break; + case NAT: + assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() ); + assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() ); + assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_NAT_DEFAULT, addedEthernetDevice.getSource() ); + break; + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test get virtualizer HW version from VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm-old-os.xml", "qemu-kvm_default-archlinux-vm-no-os.xml" } ) + public void testQemuMetaDataGetVirtualizerVersion( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final Version machineVersion = vmConfig.getVirtualizerVersion(); + + if ( vmLibvirtDomainConfig.getOsMachine() == null ) { + assertNull( machineVersion ); + } else { + assertEquals( new Version( Short.valueOf( "3" ), Short.valueOf( "1" ) ), machineVersion ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test set virtualizer HW version in VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm-old-os.xml", "qemu-kvm_default-archlinux-vm-no-os.xml" } ) + public void testQemuMetaDataSetVirtualizerVersion( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final String originalOsMachine = vmLibvirtDomainConfig.getOsMachine(); + if ( originalOsMachine != null ) { + assertEquals( "pc-q35-3.1", originalOsMachine ); + } + + final Version modifiedVersion = new Version( Short.valueOf( "4" ), Short.valueOf( "1" ) ); + vmConfig.setVirtualizerVersion( modifiedVersion ); + + final String modifiedOsMachine = vmLibvirtDomainConfig.getOsMachine(); + if ( modifiedOsMachine == null ) { + assertNull( vmConfig.getVirtualizerVersion() ); + } else { + assertEquals( modifiedVersion, vmConfig.getVirtualizerVersion() ); + assertEquals( "pc-q35-4.1", modifiedOsMachine ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationTestResources.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationTestResources.java new file mode 100644 index 0000000..4dfd0b7 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationTestResources.java @@ -0,0 +1,18 @@ +package org.openslx.virtualization.configuration; + +import java.io.File; + +import org.openslx.virtualization.configuration.logic.ConfigurationLogicTestResources; + +public class VirtualizationConfigurationTestResources +{ + public static File getVmwareVmxFile( String vmwareVmxFileName ) + { + return ConfigurationLogicTestResources.getVmwareVmxFile( vmwareVmxFileName ); + } + + public static File getVirtualBoxXmlFile( String virtualBoxXmlFileName ) + { + return ConfigurationLogicTestResources.getVirtualBoxXmlFile( virtualBoxXmlFileName ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBoxTest.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBoxTest.java new file mode 100644 index 0000000..597fffb --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBoxTest.java @@ -0,0 +1,143 @@ +package org.openslx.virtualization.configuration; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.openslx.virtualization.Version; +import org.openslx.vm.disk.DiskImage.ImageFormat; + +public class VirtualizationConfigurationVirtualBoxTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @ParameterizedTest + @DisplayName( "Test version from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetConfigurationVersion( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + assertEquals( configVersion, vmConfig.getConfigurationVersion() ); + } + + @ParameterizedTest + @DisplayName( "Test display name from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetDisplayName( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final String displayName = vmConfig.getDisplayName(); + + assertEquals( VirtualizationConfigurationVirtualBoxTest.getVmName( name, configVersion ), displayName ); + } + + @ParameterizedTest + @DisplayName( "Test machine snapshot state from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxIsMachineSnapshot( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final boolean isVmSnapshot = vmConfig.isMachineSnapshot(); + + assertFalse( isVmSnapshot ); + } + + @ParameterizedTest + @DisplayName( "Test supported image formats from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetSupportedImageFormats( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final List<ImageFormat> supportedImageFormats = vmConfig.getVirtualizer().getSupportedImageFormats(); + + assertNotNull( supportedImageFormats ); + assertEquals( 1, supportedImageFormats.size() ); + assertTrue( supportedImageFormats.containsAll( Arrays.asList( ImageFormat.VDI ) ) ); + } + + @ParameterizedTest + @DisplayName( "Test output of HDDs from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetHdds( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final List<VirtualizationConfiguration.HardDisk> hdds = vmConfig.getHdds(); + + final String imageFileName = VirtualizationConfigurationVirtualBoxTest.getVmName( name, configVersion ) + ".vdi"; + + assertNotNull( hdds ); + assertEquals( 1, hdds.size() ); + assertEquals( imageFileName, hdds.get( 0 ).diskImage ); + } + + static String getVmName( String name, Version version ) + { + return name + "_" + version.toString().replace( '.', '-' ); + } + + static Stream<Arguments> configAndVersionProvider() + { + return Stream.of( + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-15.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "15" ) ) ), + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-16.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "16" ) ) ), + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-17.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "17" ) ) ), + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-18.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "18" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-15.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "15" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-16.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "16" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-17.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "17" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-18.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "18" ) ) ) ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java new file mode 100644 index 0000000..f078b5e --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java @@ -0,0 +1,92 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; +import org.openslx.virtualization.configuration.data.ConfigurationDataDozModClientToDozModServer; +import org.openslx.virtualization.configuration.transformation.TransformationException; + +public class ConfigurationLogicDozModClientToDozModServerTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-client and a dozmod-server for Libvirt/QEMU configuration" ) + public void testConfigurationLogicDozModClientToDozModServerLibvirt() throws TransformationException + { + final String inputConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm.xml"; + final String expectedConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-privacy.xml"; + final File inputConfig = LibvirtXmlTestResources.getLibvirtXmlFile( inputConfigFileName ); + final File expectedConfig = LibvirtXmlTestResources.getLibvirtXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-client and a dozmod-server for VirtualBox configuration" ) + public void testConfigurationLogicDozModClientToDozModServerVirtualBox() throws TransformationException + { + final String inputConfigFileName = "virtualbox_default-ubuntu.vbox"; + final String expectedConfigFileName = "virtualbox_default-ubuntu_transform-privacy.vbox"; + final File inputConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + + // do not validate the VirtualBox configuration afterwards, since the inserted + // place holders do not match valid primitive values from the XML schema + //assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-client and a dozmod-server for VMware configuration" ) + public void testConfigurationLogicDozModClientToDozModServerVmware() throws TransformationException + { + final String inputConfigFileName = "vmware-player_default-ubuntu.vmx"; + final String expectedConfigFileName = "vmware-player_default-ubuntu_transform-privacy.vmx"; + final File inputConfig = ConfigurationLogicTestResources.getVmwareVmxFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVmwareVmxFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToDozModClientTest.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToDozModClientTest.java new file mode 100644 index 0000000..96180ed --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToDozModClientTest.java @@ -0,0 +1,108 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.bwlp.thrift.iface.OperatingSystem; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; +import org.openslx.virtualization.configuration.data.ConfigurationDataDozModServerToDozModClient; +import org.openslx.virtualization.configuration.transformation.TransformationException; +import org.openslx.vm.disk.DiskImageTestResources; + +public class ConfigurationLogicDozModServerToDozModClientTest +{ + private static final String DEFAULT_DISPLAY_NAME = "Test"; + private static final File DEFAULT_DISK_IMAGE = DiskImageTestResources.getDiskFile( "image-default.vmdk" ); + private static final OperatingSystem DEFAULT_GUEST_OS = null; + private static final String DEFAULT_VIRTUALIZER_ID = null; + private static final int DEFAULT_TOTAL_MEMORY = 4096; + + private static final ConfigurationDataDozModServerToDozModClient DEFAULT_CONFIG_DATA = new ConfigurationDataDozModServerToDozModClient( + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_DISPLAY_NAME, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_DISK_IMAGE, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_GUEST_OS, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_VIRTUALIZER_ID, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_TOTAL_MEMORY ); + + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a dozmod-client for Libvirt/QEMU configuration" ) + public void testConfigurationLogicDozModServerToDozModClientLibvirt() throws TransformationException + { + final String inputConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-privacy.xml"; + final String expectedConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-editable.xml"; + final File inputConfig = LibvirtXmlTestResources.getLibvirtXmlFile( inputConfigFileName ); + final File expectedConfig = LibvirtXmlTestResources.getLibvirtXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a dozmod-client for VirtualBox configuration" ) + public void testConfigurationLogicDozModServerToDozModClientVirtualBox() throws TransformationException + { + final String inputConfigFileName = "virtualbox_default-ubuntu_transform-privacy.vbox"; + final String expectedConfigFileName = "virtualbox_default-ubuntu_transform-editable.vbox"; + final File inputConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( + ConfigurationLogicTestUtils.isVirtualBoxContentEqual( expectedTransformedConfig, transformedConfig ) ); + + // do not validate the VirtualBox configuration afterwards, since the inserted network configuration + // leads to an invalid DOM although the created output after the transformation is as expected + //assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between dozmod-server and a dozmod-client for VMware configuration" ) + public void testConfigurationLogicDozModServerToDozModClientVmware() throws TransformationException + { + final String inputConfigFileName = "vmware-player_default-ubuntu_transform-privacy.vmx"; + final String expectedConfigFileName = "vmware-player_default-ubuntu_transform-editable.vmx"; + final File inputConfig = ConfigurationLogicTestResources.getVmwareVmxFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVmwareVmxFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToStatelessClientTest.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToStatelessClientTest.java new file mode 100644 index 0000000..6c87526 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToStatelessClientTest.java @@ -0,0 +1,102 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; +import org.openslx.virtualization.configuration.data.ConfigurationDataDozModServerToStatelessClient; +import org.openslx.virtualization.configuration.transformation.TransformationException; + +public class ConfigurationLogicDozModServerToStatelessClientTest +{ + private static final String DEFAULT_DISPLAY_NAME = "Test"; + private static final String DEFAULT_OS_ID = null; + private static final boolean DEFAULT_HAS_USB_ACCESS = true; + + private static final ConfigurationDataDozModServerToStatelessClient DEFAULT_CONFIG_DATA = new ConfigurationDataDozModServerToStatelessClient( + ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_DISPLAY_NAME, + ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_OS_ID, + ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_HAS_USB_ACCESS ); + + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a stateless client for Libvirt/QEMU configuration" ) + public void testConfigurationLogicDozModServerToStatelessClientLibvirt() throws TransformationException + { + final String inputConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-privacy.xml"; + final String expectedConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-non-persistent.xml"; + final File inputConfig = LibvirtXmlTestResources.getLibvirtXmlFile( inputConfigFileName ); + final File expectedConfig = LibvirtXmlTestResources.getLibvirtXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a stateless client for VirtualBox configuration" ) + public void testConfigurationLogicDozModServerToStatelessClientVirtualBox() throws TransformationException + { + final String inputConfigFileName = "virtualbox_default-ubuntu_transform-privacy.vbox"; + final String expectedConfigFileName = "virtualbox_default-ubuntu_transform-non-persistent.vbox"; + final File inputConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( + ConfigurationLogicTestUtils.isVirtualBoxContentEqual( expectedTransformedConfig, transformedConfig ) ); + + // do not validate the VirtualBox configuration afterwards, since the inserted + // place holders do not match valid primitive values from the XML schema + //assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between dozmod-server and a stateless client for VMware configuration" ) + public void testConfigurationLogicDozModServerToStatelessClientVmware() throws TransformationException + { + final String inputConfigFileName = "vmware-player_default-ubuntu_transform-privacy.vmx"; + final String expectedConfigFileName = "vmware-player_default-ubuntu_transform-non-persistent.vmx"; + final File inputConfig = ConfigurationLogicTestResources.getVmwareVmxFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVmwareVmxFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java new file mode 100644 index 0000000..ceafceb --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java @@ -0,0 +1,32 @@ +package org.openslx.virtualization.configuration.logic; + +import java.io.File; +import java.net.URL; + +public class ConfigurationLogicTestResources +{ + private static final String VMWARE_PREFIX_PATH = File.separator + "vmware"; + private static final String VMWARE_PREFIX_PATH_VMX = VMWARE_PREFIX_PATH + File.separator + "vmx"; + + private static final String VIRTUALBOX_PREFIX_PATH = File.separator + "virtualbox"; + private static final String VIRTUALBOX_PREFIX_PATH_XML = VIRTUALBOX_PREFIX_PATH + File.separator + "xml"; + + private static File getFile( String prefixPath, String fileName ) + { + final String filePath = prefixPath + File.separator + fileName; + final URL fileUrl = ConfigurationLogicTestResources.class.getResource( filePath ); + return new File( fileUrl.getFile() ); + } + + public static File getVmwareVmxFile( String vmwareVmxFileName ) + { + return ConfigurationLogicTestResources.getFile( ConfigurationLogicTestResources.VMWARE_PREFIX_PATH_VMX, + vmwareVmxFileName ); + } + + public static File getVirtualBoxXmlFile( String virtualBoxXmlFileName ) + { + return ConfigurationLogicTestResources.getFile( ConfigurationLogicTestResources.VIRTUALBOX_PREFIX_PATH_XML, + virtualBoxXmlFileName ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java new file mode 100644 index 0000000..07046b5 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java @@ -0,0 +1,100 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.fail; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.StringReader; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +import org.apache.commons.io.FileUtils; +import org.openslx.bwlp.thrift.iface.OperatingSystem; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; + +public class ConfigurationLogicTestUtils +{ + // @formatter:off + public static final List<OperatingSystem> STUB_OS_LIST = Collections.unmodifiableList( Arrays.asList( + new OperatingSystem( 1, "Windows 7 (64 Bit)", null, "AMD64", 196608, 256 ), + new OperatingSystem( 2, "Windows 8 (32 Bit)", null, "x86", 4096, 32 ), + new OperatingSystem( 3, "Windows 8 (64 Bit)", null, "AMD64", 131072, 256 ), + new OperatingSystem( 4, "Ubuntu (32 Bit)", null, "x86", 0, 0 ), + new OperatingSystem( 5, "Ubuntu (64 Bit)", null, "AMD64", 0, 0 ), + new OperatingSystem( 6, "OpenSUSE (32 Bit)", null, "x86", 0, 0 ), + new OperatingSystem( 7, "OpenSUSE (64 Bit)", null, "AMD64", 0, 0 ), + new OperatingSystem( 8, "Other Linux (32 Bit)", null, "x86", 0, 0 ), + new OperatingSystem( 9, "Other Linux (64 Bit)", null, "AMD64", 0, 0 ), + new OperatingSystem( 10, "Windows 7 (32 Bit)", null, "x86", 4096, 32 ), + new OperatingSystem( 11, "Windows 2000 Professional", null, "x86", 4096, 4 ) ) ); + // @formatter:on + + private static final String REGEX_UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"; + + public static VirtualizationConfiguration<?, ?, ?, ?> newVirtualizationConfigurationInstance( File configFile ) + { + VirtualizationConfiguration<?, ?, ?, ?> config = null; + + try { + config = VirtualizationConfiguration.getInstance( ConfigurationLogicTestUtils.STUB_OS_LIST, configFile ); + } catch ( IOException e ) { + fail( "Virtualization configuration file '" + configFile.getName() + "' can not be processed!" ); + } + + if ( config == null ) { + fail( "Virtualization configuration can not be created from file '" + configFile.getName() + "'" ); + } + + return config; + } + + public static String readFileToString( File file ) + { + String content = null; + + try { + content = FileUtils.readFileToString( file, StandardCharsets.UTF_8 ); + } catch ( IOException e ) { + fail( "Could not read content of file '" + file.getName() + "'" ); + } + + return content; + } + + public static boolean isContentEqual( String content1, String content2 ) + { + final BufferedReader bfrContent1 = new BufferedReader( new StringReader( content1 ) ); + final BufferedReader bfrContent2 = new BufferedReader( new StringReader( content2 ) ); + final List<String> linesContent1 = bfrContent1.lines().collect( Collectors.toList() ); + final List<String> linesContent2 = bfrContent2.lines().collect( Collectors.toList() ); + + Collections.sort( linesContent1 ); + Collections.sort( linesContent2 ); + + return linesContent1.equals( linesContent2 ); + } + + public static String removeUuid( String content ) + { + final Pattern patternUuid = Pattern.compile( ConfigurationLogicTestUtils.REGEX_UUID ); + final Matcher matcherUuidContent = patternUuid.matcher( content ); + + // replace all UUIDs with the empty String + return matcherUuidContent.replaceAll( "" ); + } + + public static boolean isVirtualBoxContentEqual( String content1, String content2 ) + { + // replace all UUIDs with the empty String + final String filteredContent1 = ConfigurationLogicTestUtils.removeUuid( content1 ); + final String filteredContent2 = ConfigurationLogicTestUtils.removeUuid( content2 ); + + return ConfigurationLogicTestUtils.isContentEqual( filteredContent1, filteredContent2 ); + } +} |