diff options
Diffstat (limited to 'src/test/java')
26 files changed, 3359 insertions, 0 deletions
diff --git a/src/test/java/org/openslx/firmware/QemuFirmwareTest.java b/src/test/java/org/openslx/firmware/QemuFirmwareTest.java new file mode 100644 index 0000000..3088265 --- /dev/null +++ b/src/test/java/org/openslx/firmware/QemuFirmwareTest.java @@ -0,0 +1,45 @@ +package org.openslx.firmware; + +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 java.io.File; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +public class QemuFirmwareTest +{ + @Test + @DisplayName( "Test parsing of valid QEMU firmware specification file" ) + public void testQemuFirmwareFromFwSpecValid() + { + final File fwSpecFile = QemuFirmwareTestResources.getQemuFirmwareSpecFile( "60-edk2-x86_64.json" ); + + final QemuFirmware firmware = QemuFirmware.fromFwSpec( fwSpecFile ); + + assertNotNull( firmware ); + assertEquals( "UEFI firmware for x86_64", firmware.getDescription() ); + assertEquals( 1, firmware.getInterfaceTypes().size() ); + assertEquals( "uefi", firmware.getInterfaceTypes().get( 0 ) ); + assertEquals( "/usr/share/qemu/edk2-x86_64-code.fd", firmware.getMapping().getExecutable().getFileName() ); + assertEquals( "/usr/share/qemu/edk2-i386-vars.fd", firmware.getMapping().getNvramTemplate().getFileName() ); + assertEquals( 1, firmware.getTargets().size() ); + assertEquals( "x86_64", firmware.getTargets().get( 0 ).getArchitecture() ); + assertEquals( 2, firmware.getTargets().get( 0 ).getMachines().size() ); + assertEquals( "pc-i440fx-*", firmware.getTargets().get( 0 ).getMachines().get( 0 ) ); + assertEquals( "pc-q35-*", firmware.getTargets().get( 0 ).getMachines().get( 1 ) ); + assertEquals( 3, firmware.getFeatures().size() ); + assertEquals( 0, firmware.getTags().size() ); + } + + @Test + @DisplayName( "Test parsing of invalid QEMU firmware specification file" ) + public void testQemuFirmwareFromFwSpecInvalid() + { + final QemuFirmware firmware = QemuFirmware.fromFwSpec( null ); + + assertNull( firmware ); + } +} diff --git a/src/test/java/org/openslx/firmware/QemuFirmwareTestResources.java b/src/test/java/org/openslx/firmware/QemuFirmwareTestResources.java new file mode 100644 index 0000000..05397e6 --- /dev/null +++ b/src/test/java/org/openslx/firmware/QemuFirmwareTestResources.java @@ -0,0 +1,101 @@ +package org.openslx.firmware; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLDecoder; +import java.nio.file.Files; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.Set; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; + +import org.apache.commons.io.FileUtils; +import org.openslx.util.Resources; + +public class QemuFirmwareTestResources +{ + private static final String QEMU_PREFIX_PATH = Resources.PATH_SEPARATOR + "qemu"; + private static final String QEMU_PREFIX_PATH_FW = QEMU_PREFIX_PATH + Resources.PATH_SEPARATOR + "firmware"; + + private static final String QEMU_TEMP_PREFIX = "qemu-"; + + public static String getQemuFirmwareSpecPath() + { + String fwSpecDir = null; + + try { + fwSpecDir = getResourceDirectory( QemuFirmwareTestResources.class, QEMU_PREFIX_PATH_FW ); + } catch ( IOException e ) { + fwSpecDir = null; + } + + return fwSpecDir; + } + + private static String getResourceDirectory( Class<?> clazz, String resourceDir ) throws IOException + { + final String fwDirPath = resourceDir.substring( 1 ).concat( Resources.PATH_SEPARATOR ); + final URL fwResource = clazz.getResource( resourceDir ); + final File fwDirectory; + String fwDirectoryPath = null; + + if ( fwResource != null && "jar".equals( fwResource.getProtocol() ) ) { + // create temporary directory to copy Jar files into it + fwDirectory = Files.createTempDirectory( QEMU_TEMP_PREFIX ).toFile(); + + // obtain file list from a directory within the Jar file + // strip out only the JAR file path + final String jarPath = fwResource.getPath().substring( 5, fwResource.getPath().indexOf( "!" ) ); + final JarFile jar = new JarFile( URLDecoder.decode( jarPath, "UTF-8" ) ); + // get all entries in the Jar file + final Enumeration<JarEntry> jarEntries = jar.entries(); + final Set<String> fileNames = new HashSet<String>(); + while ( jarEntries.hasMoreElements() ) { + final String jarEntryName = jarEntries.nextElement().getName(); + if ( jarEntryName.startsWith( fwDirPath ) ) { + String jarEntry = jarEntryName.substring( fwDirPath.length() ); + if ( !jarEntry.isEmpty() ) { + fileNames.add( jarEntry ); + } + } + } + + // copy each file from the Jar to the temporary directory + fileNames.forEach( fileName -> { + final String resourceFileName = resourceDir + Resources.PATH_SEPARATOR + fileName; + final File tempFile = new File( fwDirectory.getPath() + File.separator + fileName ); + final InputStream fileInput = QemuFirmwareTestResources.class.getResourceAsStream( resourceFileName ); + try { + FileUtils.copyInputStreamToFile( fileInput, tempFile ); + } catch ( IOException e ) { + e.printStackTrace(); + } + tempFile.deleteOnExit(); + } ); + fwDirectory.deleteOnExit(); + } else if ( fwResource != null && "file".equals( fwResource.getProtocol() ) ) { + fwDirectory = new File( fwResource.getFile() ); + } else { + fwDirectory = null; + } + + try { + fwDirectoryPath = fwDirectory.toURI().toURL().getFile(); + } catch ( MalformedURLException | NullPointerException e ) { + fwDirectoryPath = null; + } + + return fwDirectoryPath; + } + + public static File getQemuFirmwareSpecFile( String fileName ) + { + final String fwSpecFilePath = QEMU_PREFIX_PATH_FW + Resources.PATH_SEPARATOR + fileName; + final URL fwSpecFileUrl = QemuFirmwareTestResources.class.getResource( fwSpecFilePath ); + return new File( fwSpecFileUrl.getFile() ); + } +} diff --git a/src/test/java/org/openslx/firmware/QemuFirmwareUtilTest.java b/src/test/java/org/openslx/firmware/QemuFirmwareUtilTest.java new file mode 100644 index 0000000..75ce286 --- /dev/null +++ b/src/test/java/org/openslx/firmware/QemuFirmwareUtilTest.java @@ -0,0 +1,98 @@ +package org.openslx.firmware; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.nio.file.Paths; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.domain.Domain; +import org.openslx.libvirt.domain.DomainTest; + +public class QemuFirmwareUtilTest +{ + @Test + @DisplayName( "Test that lookup of OS loader from Libvirt domain file succeeds" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderValid() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + final Domain config = DomainTest + .getDomain( "qemu-kvm_default-ubuntu-20-04-vm_transform-non-persistent_uefi.xml" ); + + final String targetOsLoader = QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, config.getOsLoader(), + config.getOsArch(), config.getOsMachine() ); + + assertEquals( Paths.get( "/usr/share/qemu/edk2-x86_64-code.fd" ).toString(), targetOsLoader ); + } + + @Test + @DisplayName( "Test that lookup of OS loader from Archlinux path succeeds" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderValidArchlinux() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + + final String targetOsLoader = QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, + "/usr/share/edk2-ovmf/x64/OVMF_CODE.fd", "x86_64", "pc-q35-5.0" ); + + assertEquals( Paths.get( "/usr/share/qemu/edk2-x86_64-code.fd" ).toString(), targetOsLoader ); + } + + @Test + @DisplayName( "Test that lookup of OS loader from Debian path succeeds" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderValidDebian() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + + final String targetOsLoader = QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, + "/usr/share/OVMF/OVMF_CODE.fd", "x86_64", "pc-q35-5.0" ); + + assertEquals( Paths.get( "/usr/share/qemu/edk2-x86_64-code.fd" ).toString(), targetOsLoader ); + } + + @Test + @DisplayName( "Test that lookup of OS loader from CentOS path succeeds" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderValidCentOs() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + + final String targetOsLoader = QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, + "/usr/share/edk2/ovmf/OVMF_CODE.cc.fd", "x86_64", "pc-q35-5.0" ); + + assertEquals( Paths.get( "/usr/share/qemu/edk2-x86_64-code.fd" ).toString(), targetOsLoader ); + } + + @Test + @DisplayName( "Test that lookup of OS loader from OpenSUSE path succeeds" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderValidOpenSuse() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + + final String targetOsLoader = QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, + "/usr/share/qemu/ovmf-x86_64-4m-code.bin", "x86_64", "pc-q35-5.0" ); + + assertEquals( Paths.get( "/usr/share/qemu/edk2-x86_64-code.fd" ).toString(), targetOsLoader ); + } + + @Test + @DisplayName( "Test that lookup of OS loader from Ubuntu path succeeds" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderValidUbuntu() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + + final String targetOsLoader = QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, + "/usr/share/OVMF/OVMF_CODE_4M.fd", "x86_64", "pc-q35-5.0" ); + + assertEquals( Paths.get( "/usr/share/qemu/edk2-x86_64-code.fd" ).toString(), targetOsLoader ); + } + + @Test + @DisplayName( "Test that lookup of non-existent OS loader for non-existent architecture fails" ) + public void testQemuFirmwareUtilLookupTargetOsLoaderInvalid() throws FirmwareException + { + final String fwSpecPath = QemuFirmwareTestResources.getQemuFirmwareSpecPath(); + + assertThrows( FirmwareException.class, () -> QemuFirmwareUtil.lookupTargetOsLoader( fwSpecPath, + Paths.get( "/non/existent/loader.fd" ).toString(), "x87", "pc-q35-6.0" ) ); + } +} diff --git a/src/test/java/org/openslx/libvirt/capabilities/CapabilitiesTest.java b/src/test/java/org/openslx/libvirt/capabilities/CapabilitiesTest.java new file mode 100644 index 0000000..fd90698 --- /dev/null +++ b/src/test/java/org/openslx/libvirt/capabilities/CapabilitiesTest.java @@ -0,0 +1,305 @@ +package org.openslx.libvirt.capabilities; + +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.fail; + +import java.math.BigInteger; +import java.util.List; + +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.capabilities.cpu.Cpu; +import org.openslx.libvirt.capabilities.cpu.Feature; +import org.openslx.libvirt.capabilities.cpu.Pages; +import org.openslx.libvirt.capabilities.guest.Domain; +import org.openslx.libvirt.capabilities.guest.Guest; +import org.openslx.libvirt.capabilities.guest.Machine; +import org.openslx.libvirt.domain.Domain.OsType; +import org.openslx.libvirt.domain.Domain.Type; +import org.openslx.libvirt.xml.LibvirtXmlDocumentException; +import org.openslx.libvirt.xml.LibvirtXmlSerializationException; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.libvirt.xml.LibvirtXmlValidationException; + +public class CapabilitiesTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + Configurator.setRootLevel( Level.OFF ); + } + + private Capabilities newCapabilitiesInstance( String xmlFileName ) + { + Capabilities caps = null; + + try { + caps = new Capabilities( LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ) ); + } catch ( LibvirtXmlDocumentException | LibvirtXmlSerializationException | LibvirtXmlValidationException e ) { + final String errorMsg = new String( + "Cannot prepare requested Libvirt capabilities XML file from the resources folder" ); + fail( errorMsg ); + } + + return caps; + } + + @Test + @DisplayName( "Get host UUID from libvirt XML capabilities file" ) + public void testGetHostUuid() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + + assertEquals( "9b2f12af-1fba-444c-b72b-9cbc43fb3ca5", caps.getHostUuid() ); + } + + @Test + @DisplayName( "Get host CPU from libvirt XML capabilities file" ) + public void testGetHostCpu() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + final Cpu hostCpu = caps.getHostCpu(); + + assertNotNull( hostCpu ); + assertEquals( "x86_64", hostCpu.getArch() ); + assertEquals( "Skylake-Client-IBRS", hostCpu.getModel() ); + assertEquals( "Intel", hostCpu.getVendor() ); + assertEquals( 1, hostCpu.getTopologySockets() ); + assertEquals( 1, hostCpu.getTopologyDies() ); + assertEquals( 4, hostCpu.getTopologyCores() ); + assertEquals( 1, hostCpu.getTopologyThreads() ); + } + + @Test + @DisplayName( "Get non-existent host CPU from libvirt XML capabilities file" ) + public void testGetHostCpuNonExistent() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-cpu.xml" ); + final Cpu hostCpu = caps.getHostCpu(); + + assertNull( hostCpu ); + } + + @Test + @DisplayName( "Get host CPU features from libvirt XML capabilities file" ) + public void testGetHostCpuFeatures() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + final Cpu hostCpu = caps.getHostCpu(); + + assertNotNull( hostCpu ); + + final List<Feature> hostCpuFeatures = hostCpu.getFeatures(); + assertNotNull( hostCpuFeatures ); + assertEquals( 25, hostCpuFeatures.size() ); + + final Feature hostCpuFeature = hostCpuFeatures.get( 9 ); + assertNotNull( hostCpuFeature ); + assertEquals( "vmx", hostCpuFeature.getName() ); + } + + @Test + @DisplayName( "Get empty host CPU features from libvirt XML capabilities file" ) + public void testGetHostCpuFeaturesEmpty() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-cpu-features.xml" ); + final Cpu hostCpu = caps.getHostCpu(); + + assertNotNull( hostCpu ); + + final List<Feature> hostCpuFeatures = hostCpu.getFeatures(); + assertNotNull( hostCpuFeatures ); + assertEquals( 0, hostCpuFeatures.size() ); + } + + @Test + @DisplayName( "Get host CPU pages from libvirt XML capabilities file" ) + public void testGetHostCpuPages() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + final Cpu hostCpu = caps.getHostCpu(); + + assertNotNull( hostCpu ); + + final List<Pages> hostCpuPages = hostCpu.getPages(); + assertNotNull( hostCpuPages ); + assertEquals( 3, hostCpuPages.size() ); + + final Pages hostCpuPage = hostCpuPages.get( 2 ); + assertNotNull( hostCpuPage ); + assertEquals( new BigInteger( "1073741824" ).toString(), hostCpuPage.getSize().toString() ); + } + + @Test + @DisplayName( "Get empty host CPU pages from libvirt XML capabilities file" ) + public void testGetHostCpuPagesEmpty() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-cpu-pages.xml" ); + final Cpu hostCpu = caps.getHostCpu(); + + assertNotNull( hostCpu ); + + final List<Pages> hostCpuPages = hostCpu.getPages(); + assertNotNull( hostCpuPages ); + assertEquals( 0, hostCpuPages.size() ); + } + + @Test + @DisplayName( "Get host IOMMU support from libvirt XML capabilities file" ) + public void testGetHostIommuSupport() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + + assertEquals( true, caps.hasHostIommuSupport() ); + } + + @Test + @DisplayName( "Get non-existent host IOMMU support from libvirt XML capabilities file" ) + public void testGetHostIommuSupportNonExistent() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-iommu.xml" ); + + assertEquals( false, caps.hasHostIommuSupport() ); + } + + @Test + @DisplayName( "Get guests from libvirt XML capabilities file" ) + public void testGetGuests() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 26, guests.size() ); + + final Guest guest = guests.get( 3 ); + assertNotNull( guest ); + assertEquals( OsType.HVM.toString(), guest.getOsType().toString() ); + assertEquals( "aarch64", guest.getArchName() ); + assertEquals( 64, guest.getArchWordSize() ); + assertEquals( "/usr/bin/qemu-system-aarch64", guest.getArchEmulator() ); + } + + @Test + @DisplayName( "Get empty guests from libvirt XML capabilities file" ) + public void testGetGuestsEmpty() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-guests.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 0, guests.size() ); + } + + @Test + @DisplayName( "Get guest machines from libvirt XML capabilities file" ) + public void testGetGuestMachines() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 26, guests.size() ); + + final Guest guest = guests.get( 3 ); + assertNotNull( guest ); + + final List<Machine> guestMachines = guest.getArchMachines(); + assertNotNull( guestMachines ); + assertEquals( 89, guestMachines.size() ); + + final Machine guestMachine = guestMachines.get( 5 ); + assertNotNull( guestMachine ); + assertNull( guestMachine.getCanonicalMachine() ); + assertEquals( 2, guestMachine.getMaxCpus() ); + assertEquals( "nuri", guestMachine.getName() ); + } + + @Test + @DisplayName( "Get empty guest machines from libvirt XML capabilities file" ) + public void testGetGuestMachinesEmpty() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-guest-machines.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 26, guests.size() ); + + final Guest guest = guests.get( 3 ); + assertNotNull( guest ); + + final List<Machine> guestMachines = guest.getArchMachines(); + assertNotNull( guestMachines ); + assertEquals( 0, guestMachines.size() ); + } + + @Test + @DisplayName( "Get canonical guest machine from libvirt XML capabilities file" ) + public void testGetGuestMachineCanonical() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 26, guests.size() ); + + final Guest guest = guests.get( 3 ); + assertNotNull( guest ); + + final List<Machine> guestMachines = guest.getArchMachines(); + assertNotNull( guestMachines ); + assertEquals( 89, guestMachines.size() ); + + final Machine guestMachine = guestMachines.get( 29 ); + assertNotNull( guestMachine ); + assertEquals( "virt-5.2", guestMachine.getCanonicalMachine() ); + assertEquals( 512, guestMachine.getMaxCpus() ); + assertEquals( "virt", guestMachine.getName() ); + } + + @Test + @DisplayName( "Get guest machine domains from libvirt XML capabilities file" ) + public void testGetGuestMachineDomains() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_default.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 26, guests.size() ); + + final Guest guest = guests.get( 5 ); + assertNotNull( guest ); + + final List<Domain> guestDomains = guest.getArchDomains(); + assertNotNull( guestDomains ); + assertEquals( 2, guestDomains.size() ); + + final Domain guestDomain = guestDomains.get( 1 ); + assertNotNull( guestDomain ); + assertEquals( Type.KVM, guestDomain.getType() ); + } + + @Test + @DisplayName( "Get empty guest machine domains from libvirt XML capabilities file" ) + public void testGetGuestMachineDomainsEmpty() + { + final Capabilities caps = this.newCapabilitiesInstance( "qemu-kvm_capabilities_no-guest-machines.xml" ); + + final List<Guest> guests = caps.getGuests(); + assertNotNull( guests ); + assertEquals( 26, guests.size() ); + + final Guest guest = guests.get( 3 ); + assertNotNull( guest ); + + final List<Domain> guestDomains = guest.getArchDomains(); + assertNotNull( guestDomains ); + assertEquals( 0, guestDomains.size() ); + } +} diff --git a/src/test/java/org/openslx/libvirt/domain/DomainTest.java b/src/test/java/org/openslx/libvirt/domain/DomainTest.java new file mode 100644 index 0000000..f55c511 --- /dev/null +++ b/src/test/java/org/openslx/libvirt/domain/DomainTest.java @@ -0,0 +1,518 @@ +package org.openslx.libvirt.domain; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.fail; + +import java.math.BigInteger; + +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.domain.Domain.CpuCheck; +import org.openslx.libvirt.domain.Domain.CpuMode; +import org.openslx.libvirt.domain.Domain.OsType; +import org.openslx.libvirt.xml.LibvirtXmlDocumentException; +import org.openslx.libvirt.xml.LibvirtXmlSerializationException; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.libvirt.xml.LibvirtXmlValidationException; + +public class DomainTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + Configurator.setRootLevel( Level.OFF ); + } + + public static Domain getDomain( String xmlFileName ) + { + Domain domain = null; + + try { + domain = new Domain( LibvirtXmlTestResources.getLibvirtXmlStream( xmlFileName ) ); + } catch ( LibvirtXmlDocumentException | LibvirtXmlSerializationException | LibvirtXmlValidationException e ) { + String errorMsg = new String( "Cannot prepare requested Libvirt domain XML file from the resources folder" ); + fail( errorMsg ); + } + + return domain; + } + + @Test + @DisplayName( "Get VM type from libvirt XML file" ) + public void testGetType() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( Domain.Type.KVM.toString(), vm.getType().toString() ); + } + + @Test + @DisplayName( "Set VM type from libvirt XML file" ) + public void testSetType() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setType( Domain.Type.QEMU ); + assertEquals( Domain.Type.QEMU.toString(), vm.getType().toString() ); + } + + @Test + @DisplayName( "Get VM name from libvirt XML file" ) + public void testGetName() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "ubuntu-20-04", vm.getName() ); + } + + @Test + @DisplayName( "Set VM name in libvirt XML file" ) + public void testSetName() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setName( "ubuntu-18-04" ); + assertEquals( "ubuntu-18-04", vm.getName() ); + } + + @Test + @DisplayName( "Get VM title from libvirt XML file" ) + public void testGetTitle() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "Ubuntu 20.04", vm.getTitle() ); + } + + @Test + @DisplayName( "Set VM title in libvirt XML file" ) + public void testSetTitle() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setTitle( "Ubuntu 18.04" ); + assertEquals( "Ubuntu 18.04", vm.getTitle() ); + } + + @Test + @DisplayName( "Get VM description from libvirt XML file" ) + public void testGetDescription() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "Ubuntu 20.04 desktop installation", vm.getDescription() ); + } + + @Test + @DisplayName( "Set VM description in libvirt XML file" ) + public void testSetDescription() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setDescription( "Ubuntu 18.04 server installation" ); + assertEquals( "Ubuntu 18.04 server installation", vm.getDescription() ); + } + + @Test + @DisplayName( "Get VM libosinfo operating system identifier in libvirt XML file" ) + public void testGetLibOsInfoOsId() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "http://ubuntu.com/ubuntu/20.04", vm.getLibOsInfoOsId() ); + } + + @Test + @DisplayName( "Get VM UUID from libvirt XML file" ) + public void testGetUuid() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "8dc5433c-0228-49e4-b019-fa2b606aa544", vm.getUuid() ); + } + + @Test + @DisplayName( "Set VM UUID in libvirt XML file" ) + public void testSetUuid() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setUuid( "5ab08167-3d95-400e-ac83-e6af8d150971" ); + assertEquals( "5ab08167-3d95-400e-ac83-e6af8d150971", vm.getUuid() ); + } + + @Test + @DisplayName( "Get VM memory from libvirt XML file" ) + public void testGetMemory() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( new BigInteger( "4294967296" ).toString(), vm.getMemory().toString() ); + } + + @Test + @DisplayName( "Set VM memory in libvirt XML file" ) + public void testSetMemory() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setMemory( new BigInteger( "12073740288" ) ); + assertEquals( new BigInteger( "12073740288" ).toString(), vm.getMemory().toString() ); + } + + @Test + @DisplayName( "Get current VM memory from libvirt XML file" ) + public void testGetCurrentMemory() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( new BigInteger( "4294967296" ).toString(), vm.getCurrentMemory().toString() ); + } + + @Test + @DisplayName( "Set current VM memory in libvirt XML file" ) + public void testSetCurrentMemory() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setCurrentMemory( new BigInteger( "8087237632" ) ); + assertEquals( new BigInteger( "8087237632" ).toString(), vm.getCurrentMemory().toString() ); + } + + @Test + @DisplayName( "Get VM number of vCpus from libvirt XML file" ) + public void testGetVCpu() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 2, vm.getVCpu() ); + } + + @Test + @DisplayName( "Set VM number of vCpus in libvirt XML file" ) + public void testSetVCpu() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setVCpu( 4 ); + assertEquals( 4, vm.getVCpu() ); + } + + @Test + @DisplayName( "Get VM's OS type from libvirt XML file" ) + public void testGetOsType() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( OsType.HVM.toString(), vm.getOsType().toString() ); + } + + @Test + @DisplayName( "Set VM's OS type in libvirt XML file" ) + public void testSetOsType() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setOsType( OsType.XEN ); + assertEquals( OsType.XEN.toString(), vm.getOsType().toString() ); + } + + @Test + @DisplayName( "Get VM's OS architecture from libvirt XML file" ) + public void testGetOsArch() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "x86_64", vm.getOsArch() ); + } + + @Test + @DisplayName( "Set VM's OS architecture in libvirt XML file" ) + public void testSetOsArch() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setOsArch( "aarch" ); + assertEquals( "aarch", vm.getOsArch() ); + } + + @Test + @DisplayName( "Get VM's OS machine from libvirt XML file" ) + public void testGetOsMachine() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "pc-q35-5.1", vm.getOsMachine() ); + } + + @Test + @DisplayName( "Set VM's OS machine in libvirt XML file" ) + public void testSetOsMachine() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setOsMachine( "pc" ); + assertEquals( "pc", vm.getOsMachine() ); + } + + @Test + @DisplayName( "Get VM's OS loader from libvirt XML file" ) + public void testGetOsLoader() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_uefi.xml" ); + assertEquals( "/usr/share/edk2-ovmf/x64/OVMF_CODE.fd", vm.getOsLoader() ); + } + + @Test + @DisplayName( "Set VM's OS loader in libvirt XML file" ) + public void testSetOsLoader() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_uefi.xml" ); + vm.setOsLoader( "/usr/share/qemu/edk2-x86_64-code.fd" ); + assertEquals( "/usr/share/qemu/edk2-x86_64-code.fd", vm.getOsLoader() ); + } + + @Test + @DisplayName( "Get VM's OS Nvram from libvirt XML file" ) + public void testGetOsNvram() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_uefi.xml" ); + assertEquals( "/var/lib/libvirt/nvram/guest_VARS.fd", vm.getOsNvram() ); + } + + @Test + @DisplayName( "Set VM's OS Nvram in libvirt XML file" ) + public void testSetOsNvram() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_uefi.xml" ); + vm.setOsNvram( "/tmp/nvram-tmp/tmp_VARS.fd" ); + assertEquals( "/tmp/nvram-tmp/tmp_VARS.fd", vm.getOsNvram() ); + } + + @Test + @DisplayName( "Get VM CPU model from libvirt XML file" ) + public void testGetCpuModel() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertNull( vm.getCpuModel() ); + } + + @Test + @DisplayName( "Set VM CPU model in libvirt XML file" ) + public void testSetCpuModel() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setCpuModel( "core2duo" ); + assertEquals( "core2duo", vm.getCpuModel() ); + } + + @Test + @DisplayName( "Get VM CPU mode from libvirt XML file" ) + public void testGetCpuModelMode() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( CpuMode.HOST_MODEL.toString(), vm.getCpuMode().toString() ); + } + + @Test + @DisplayName( "Set VM CPU mode in libvirt XML file" ) + public void testSetCpuModelMode() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setCpuMode( CpuMode.HOST_PASSTHROUGH ); + assertEquals( CpuMode.HOST_PASSTHROUGH.toString(), vm.getCpuMode().toString() ); + } + + @Test + @DisplayName( "Get VM CPU check from libvirt XML file" ) + public void testGetCpuCheck() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( CpuCheck.PARTIAL.toString(), vm.getCpuCheck().toString() ); + } + + @Test + @DisplayName( "Set VM CPU check in libvirt XML file" ) + public void testSetCpuCheck() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setCpuCheck( CpuCheck.NONE ); + assertEquals( CpuCheck.NONE.toString(), vm.getCpuCheck().toString() ); + } + + @Test + @DisplayName( "Get VM CPU dies from libvirt XML file" ) + public void testGetCpuDies() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + assertEquals( 2, vm.getCpuDies() ); + } + + @Test + @DisplayName( "Set VM CPU dies in libvirt XML file" ) + public void testSetCpuDies() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + vm.setCpuDies( 3 ); + assertEquals( 3, vm.getCpuDies() ); + } + + @Test + @DisplayName( "Get VM CPU sockets from libvirt XML file" ) + public void testGetCpuSockets() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + assertEquals( 3, vm.getCpuSockets() ); + } + + @Test + @DisplayName( "Set VM CPU sockets in libvirt XML file" ) + public void testSetCpuSockets() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + vm.setCpuSockets( 2 ); + assertEquals( 2, vm.getCpuSockets() ); + } + + @Test + @DisplayName( "Get VM CPU cores from libvirt XML file" ) + public void testGetCpuCores() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + assertEquals( 4, vm.getCpuCores() ); + } + + @Test + @DisplayName( "Set VM CPU cores in libvirt XML file" ) + public void testSetCpuCores() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + vm.setCpuCores( 8 ); + assertEquals( 8, vm.getCpuCores() ); + } + + @Test + @DisplayName( "Get VM CPU threads from libvirt XML file" ) + public void testGetCpuThreads() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + assertEquals( 1, vm.getCpuThreads() ); + } + + @Test + @DisplayName( "Set VM CPU threads in libvirt XML file" ) + public void testSetCpuThreads() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_cpu-topology.xml" ); + vm.setCpuThreads( 2 ); + assertEquals( 2, vm.getCpuThreads() ); + } + + @Test + @DisplayName( "Get VM emulator binary from libvirt XML file" ) + public void testGetDevicesEmulator() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "/usr/bin/qemu-system-x86_64", vm.getDevicesEmulator() ); + } + + @Test + @DisplayName( "Set VM emulator binary in libvirt XML file" ) + public void testSetDevicesEmulator() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setDevicesEmulator( "/usr/bin/qemu-system-i386" ); + assertEquals( "/usr/bin/qemu-system-i386", vm.getDevicesEmulator() ); + } + + @Test + @DisplayName( "Get all VM devices from libvirt XML file" ) + public void testGetDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 22, vm.getDevices().size() ); + } + + @Test + @DisplayName( "Get all VM controller devices from libvirt XML file" ) + public void testGetControllerDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 14, vm.getControllerDevices().size() ); + } + + @Test + @DisplayName( "Get all VM disk devices from libvirt XML file" ) + public void testGetDiskDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 3, vm.getDiskDevices().size() ); + } + + @Test + @DisplayName( "Get all VM file system devices from libvirt XML file" ) + public void testGetFileSystemDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 0, vm.getFileSystemDevices().size() ); + } + + @Test + @DisplayName( "Get all VM hostdev devices from libvirt XML file" ) + public void testGetHostdevDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 0, vm.getHostdevDevices().size() ); + } + + @Test + @DisplayName( "Get all VM interface devices from libvirt XML file" ) + public void testGetInterfaceDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 1, vm.getInterfaceDevices().size() ); + } + + @Test + @DisplayName( "Get all VM graphic devices from libvirt XML file" ) + public void testGetGraphicDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 1, vm.getGraphicDevices().size() ); + } + + @Test + @DisplayName( "Get all VM parallel port devices from libvirt XML file" ) + public void testGetParallelDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 0, vm.getParallelDevices().size() ); + } + + @Test + @DisplayName( "Get all VM serial port devices from libvirt XML file" ) + public void testGetSerialDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 1, vm.getSerialDevices().size() ); + } + + @Test + @DisplayName( "Get all VM sound devices from libvirt XML file" ) + public void testGetSoundDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 1, vm.getSoundDevices().size() ); + } + + @Test + @DisplayName( "Get all VM video devices from libvirt XML file" ) + public void testGetVideoDevices() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 1, vm.getVideoDevices().size() ); + } + + @Test + @DisplayName( "Get all QEMU command line arguments from libvirt XML file" ) + public void testGetQemuCmdlnArguments() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm_qemu-cmdln.xml" ); + assertEquals( 2, vm.getQemuCmdlnArguments().size() ); + } + + @Test + @DisplayName( "Set QEMU command line arguments in libvirt XML file" ) + public void testAddQemuCmdlnArguments() + { + Domain vm = DomainTest.getDomain( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( 0, vm.getQemuCmdlnArguments().size() ); + + vm.addQemuCmdlnArgument( "-set" ); + vm.addQemuCmdlnArgument( "device.hostdev0.x-igd-opregion=on" ); + + assertEquals( 2, vm.getQemuCmdlnArguments().size() ); + } +} diff --git a/src/test/java/org/openslx/libvirt/domain/device/HostdevMdevDeviceAddressTest.java b/src/test/java/org/openslx/libvirt/domain/device/HostdevMdevDeviceAddressTest.java new file mode 100644 index 0000000..15e419e --- /dev/null +++ b/src/test/java/org/openslx/libvirt/domain/device/HostdevMdevDeviceAddressTest.java @@ -0,0 +1,71 @@ +package org.openslx.libvirt.domain.device; + +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.UUID; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +public class HostdevMdevDeviceAddressTest +{ + @Test + @DisplayName( "Test that a mediated device address instance is parsed from a valid String" ) + public void testHostdevMdevDeviceAddressValueOfValid() + { + final UUID deviceAddress = UUID.randomUUID(); + final HostdevMdevDeviceAddress mdevDeviceAddr = HostdevMdevDeviceAddress + .valueOf( deviceAddress.toString() ); + + assertNotNull( mdevDeviceAddr ); + assertEquals( deviceAddress, mdevDeviceAddr.getDeviceAddress() ); + assertEquals( deviceAddress.toString(), mdevDeviceAddr.getDeviceAddressAsString() ); + } + + @Test + @DisplayName( "Test that no mediated device address instance is parsed from an invalid String" ) + public void testHostdevMdevDeviceAddressValueOfInvalid() + { + final HostdevMdevDeviceAddress mdevDeviceAddr = HostdevMdevDeviceAddress.valueOf( "0xaffe" ); + + assertNull( mdevDeviceAddr ); + } + + @Test + @DisplayName( "Test that two mediated device address instances are equal" ) + public void testHostdevMdevDeviceAddressEquals() + { + final HostdevMdevDeviceAddress mdevDeviceAddr1 = new HostdevMdevDeviceAddress( + new UUID( 0xdeadaffe, 0xaffedead ) ); + final HostdevMdevDeviceAddress mdevDeviceAddr2 = new HostdevMdevDeviceAddress( + new UUID( 0xdeadaffe, 0xaffedead ) ); + + assertTrue( mdevDeviceAddr1.equals( mdevDeviceAddr2 ) ); + } + + @Test + @DisplayName( "Test that two mediated device address instances are not equal" ) + public void testHostdevMdevDeviceAddressNotEquals() + { + final HostdevMdevDeviceAddress mdevDeviceAddr1 = new HostdevMdevDeviceAddress( + new UUID( 0xdeadaffe, 0xaffedead ) ); + final HostdevMdevDeviceAddress mdevDeviceAddr2 = new HostdevMdevDeviceAddress( + new UUID( 0xaffedead, 0xdeadaffe ) ); + + assertFalse( mdevDeviceAddr1.equals( mdevDeviceAddr2 ) ); + } + + @Test + @DisplayName( "Test that a mediated device address can be dumped to a String" ) + public void testHostdevMdevDeviceAddressToString() + { + final UUID deviceAddr = UUID.randomUUID(); + final HostdevMdevDeviceAddress mdevDeviceAddr = new HostdevMdevDeviceAddress( deviceAddr ); + + assertEquals( deviceAddr.toString(), mdevDeviceAddr.toString() ); + } +} diff --git a/src/test/java/org/openslx/libvirt/domain/device/HostdevPciDeviceAddressTest.java b/src/test/java/org/openslx/libvirt/domain/device/HostdevPciDeviceAddressTest.java new file mode 100644 index 0000000..377e126 --- /dev/null +++ b/src/test/java/org/openslx/libvirt/domain/device/HostdevPciDeviceAddressTest.java @@ -0,0 +1,79 @@ +package org.openslx.libvirt.domain.device; + +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +public class HostdevPciDeviceAddressTest +{ + @Test + @DisplayName( "Test that a PCI device address instance is not created if invalid values are specified" ) + public void testHostdevPciDeviceAddressInstanceInvalid() + { + assertThrows( IllegalArgumentException.class, + () -> new HostdevPciDeviceAddress( Integer.MIN_VALUE, 0x03, 0x0a, 0x7 ) ); + assertThrows( IllegalArgumentException.class, + () -> new HostdevPciDeviceAddress( 0x72ab, 0x0c, 0x1a, Integer.MAX_VALUE ) ); + } + + @Test + @DisplayName( "Test that a PCI device address instance is parsed from a valid String" ) + public void testHostdevPciDeviceAddressValueOfValid() + { + final HostdevPciDeviceAddress pciDeviceAddr = HostdevPciDeviceAddress.valueOf( "002b:2a:1f.1" ); + + assertNotNull( pciDeviceAddr ); + assertEquals( 0x002b, pciDeviceAddr.getPciDomain() ); + assertEquals( "002b", pciDeviceAddr.getPciDomainAsString() ); + assertEquals( 0x2a, pciDeviceAddr.getPciBus() ); + assertEquals( "2a", pciDeviceAddr.getPciBusAsString() ); + assertEquals( 0x1f, pciDeviceAddr.getPciDevice() ); + assertEquals( "1f", pciDeviceAddr.getPciDeviceAsString() ); + assertEquals( 0x1, pciDeviceAddr.getPciFunction() ); + assertEquals( "1", pciDeviceAddr.getPciFunctionAsString() ); + } + + @Test + @DisplayName( "Test that no PCI device address instance is parsed from an invalid String" ) + public void testHostdevPciDeviceAddressValueOfInvalid() + { + final HostdevPciDeviceAddress pciDeviceAddr = HostdevPciDeviceAddress.valueOf( "0000b2ac1f31" ); + + assertNull( pciDeviceAddr ); + } + + @Test + @DisplayName( "Test that two PCI device address instances are equal" ) + public void testHostdevPciDeviceAddressEquals() + { + final HostdevPciDeviceAddress pciDeviceAddr1 = new HostdevPciDeviceAddress( 0x0000, 0x2a, 0x1f, 0x1 ); + final HostdevPciDeviceAddress pciDeviceAddr2 = new HostdevPciDeviceAddress( 0x0000, 0x2a, 0x1f, 0x1 ); + + assertTrue( pciDeviceAddr1.equals( pciDeviceAddr2 ) ); + } + + @Test + @DisplayName( "Test that two PCI device address instances are not equal" ) + public void testHostdevPciDeviceAddressNotEquals() + { + final HostdevPciDeviceAddress pciDeviceAddr1 = new HostdevPciDeviceAddress( 0x0000, 0x2a, 0x1f, 0x1 ); + final HostdevPciDeviceAddress pciDeviceAddr2 = new HostdevPciDeviceAddress( 0x0000, 0x2a, 0x1f, 0x2 ); + + assertFalse( pciDeviceAddr1.equals( pciDeviceAddr2 ) ); + } + + @Test + @DisplayName( "Test that a PCI device address can be dumped to a String" ) + public void testHostdevPciDeviceAddressToString() + { + final HostdevPciDeviceAddress pciDeviceAddr = new HostdevPciDeviceAddress( 0x0000, 0x2a, 0x1f, 0x1 ); + + assertEquals( "0000:2a:1f.1", pciDeviceAddr.toString() ); + } +} diff --git a/src/test/java/org/openslx/libvirt/domain/device/HostdevPciDeviceDescriptionTest.java b/src/test/java/org/openslx/libvirt/domain/device/HostdevPciDeviceDescriptionTest.java new file mode 100644 index 0000000..7a740ac --- /dev/null +++ b/src/test/java/org/openslx/libvirt/domain/device/HostdevPciDeviceDescriptionTest.java @@ -0,0 +1,75 @@ +package org.openslx.libvirt.domain.device; + +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +public class HostdevPciDeviceDescriptionTest +{ + @Test + @DisplayName( "Test that a PCI device description instance is not created if invalid values are specified" ) + public void testHostdevPciDeviceDescriptionInstanceInvalid() + { + assertThrows( IllegalArgumentException.class, + () -> new HostdevPciDeviceDescription( Integer.MIN_VALUE, 0x293a ) ); + assertThrows( IllegalArgumentException.class, + () -> new HostdevPciDeviceDescription( 0x8086, Integer.MAX_VALUE ) ); + } + + @Test + @DisplayName( "Test that a PCI device description instance is parsed from a valid String" ) + public void testHostdevPciDeviceDescriptionValueOfValid() + { + final HostdevPciDeviceDescription pciDeviceDesc = HostdevPciDeviceDescription.valueOf( "8086:293a" ); + + assertNotNull( pciDeviceDesc ); + assertEquals( 0x8086, pciDeviceDesc.getVendorId() ); + assertEquals( "8086", pciDeviceDesc.getVendorIdAsString() ); + assertEquals( 0x293a, pciDeviceDesc.getDeviceId() ); + assertEquals( "293a", pciDeviceDesc.getDeviceIdAsString() ); + } + + @Test + @DisplayName( "Test that no PCI device description instance is parsed from an invalid String" ) + public void testHostdevPciDeviceDescriptionValueOfInvalid() + { + final HostdevPciDeviceDescription pciDeviceDesc = HostdevPciDeviceDescription.valueOf( "bba93e215" ); + + assertNull( pciDeviceDesc ); + } + + @Test + @DisplayName( "Test that two PCI device description instances are equal" ) + public void testHostdevPciDeviceDescriptionEquals() + { + final HostdevPciDeviceDescription pciDeviceDesc1 = new HostdevPciDeviceDescription( 0x8086, 0x293a ); + final HostdevPciDeviceDescription pciDeviceDesc2 = new HostdevPciDeviceDescription( 0x8086, 0x293a ); + + assertTrue( pciDeviceDesc1.equals( pciDeviceDesc2 ) ); + } + + @Test + @DisplayName( "Test that two PCI device description instances are not equal" ) + public void testHostdevPciDeviceDescriptionNotEquals() + { + final HostdevPciDeviceDescription pciDeviceDesc1 = new HostdevPciDeviceDescription( 0x8086, 0x293a ); + final HostdevPciDeviceDescription pciDeviceDesc2 = new HostdevPciDeviceDescription( 0x293a, 0x8086 ); + + assertFalse( pciDeviceDesc1.equals( pciDeviceDesc2 ) ); + } + + @Test + @DisplayName( "Test that a PCI device description can be dumped to a String" ) + public void testHostdevPciDeviceDescriptionToString() + { + final HostdevPciDeviceDescription pciDeviceDesc = new HostdevPciDeviceDescription( 0x00b1, 0x293a ); + + assertEquals( "00b1:293a", pciDeviceDesc.toString() ); + } +} diff --git a/src/test/java/org/openslx/libvirt/libosinfo/LibOsInfoTest.java b/src/test/java/org/openslx/libvirt/libosinfo/LibOsInfoTest.java new file mode 100644 index 0000000..af1c611 --- /dev/null +++ b/src/test/java/org/openslx/libvirt/libosinfo/LibOsInfoTest.java @@ -0,0 +1,28 @@ +package org.openslx.libvirt.libosinfo; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.libosinfo.os.Os; +import org.openslx.virtualization.Version; + +public class LibOsInfoTest +{ + @Test + @DisplayName( "Test the lookup of an operating system" ) + public void testOsLookup() + { + final String osId = "http://ubuntu.com/ubuntu/20.04"; + final Os os = LibOsInfo.lookupOs( osId ); + + assertNotNull( os ); + + assertEquals( osId, os.getId() ); + assertEquals( "Ubuntu 20.04", os.getName() ); + assertEquals( "linux", os.getFamily() ); + assertEquals( "ubuntu", os.getDistro() ); + assertEquals( new Version( Short.valueOf( "20" ), Short.valueOf( "04" ) ), os.getVersion() ); + } +} diff --git a/src/test/java/org/openslx/libvirt/xml/LibvirtXmlDocumentTest.java b/src/test/java/org/openslx/libvirt/xml/LibvirtXmlDocumentTest.java new file mode 100644 index 0000000..56ceeed --- /dev/null +++ b/src/test/java/org/openslx/libvirt/xml/LibvirtXmlDocumentTest.java @@ -0,0 +1,280 @@ +package org.openslx.libvirt.xml; + +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.assertThrows; +import static org.junit.jupiter.api.Assertions.fail; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; +import java.io.StringReader; +import java.nio.charset.StandardCharsets; + +import org.apache.commons.io.FileUtils; +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.function.Executable; + +class LibvirtXmlDocumentStub extends LibvirtXmlDocument +{ + public LibvirtXmlDocumentStub( File xml ) + throws LibvirtXmlDocumentException, LibvirtXmlSerializationException, LibvirtXmlValidationException + { + super( xml ); + } + + public LibvirtXmlDocumentStub( File xml, InputStream rngSchema ) + throws LibvirtXmlDocumentException, LibvirtXmlSerializationException, LibvirtXmlValidationException + { + super( xml, rngSchema ); + } +} + +public class LibvirtXmlDocumentTest +{ + private static final String EMPTY = new String(); + + @BeforeAll + public static void setUp() + { + // disable logging with log4j + Configurator.setRootLevel( Level.OFF ); + } + + private LibvirtXmlDocument newLibvirtXmlDocumentInstance( String xmlFileName ) + { + LibvirtXmlDocument document = null; + + try { + File xmlFile = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + document = new LibvirtXmlDocumentStub( xmlFile ); + } catch ( LibvirtXmlDocumentException | LibvirtXmlSerializationException | LibvirtXmlValidationException e ) { + String errorMsg = new String( "Cannot prepare requested Libvirt XML file from the resources folder" ); + fail( errorMsg ); + } + + return document; + } + + private LibvirtXmlDocument newLibvirtXmlDocumentValidationInstance( String xmlFileName, String rngSchemaFileName ) + throws LibvirtXmlValidationException + { + LibvirtXmlDocument document = null; + + try { + File xmlFile = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + InputStream rngSchema = LibvirtXmlResources.getLibvirtRng( rngSchemaFileName ); + document = new LibvirtXmlDocumentStub( xmlFile, rngSchema ); + } catch ( LibvirtXmlDocumentException | LibvirtXmlSerializationException e ) { + String errorMsg = new String( "Cannot prepare requested Libvirt XML file from the resources folder" ); + fail( errorMsg ); + } + + return document; + } + + private static long countLines( Reader input ) throws IOException + { + final BufferedReader bfrContent = new BufferedReader( input ); + return bfrContent.lines().count(); + } + + public static long countLinesFromString( String input ) throws IOException + { + return LibvirtXmlDocumentTest.countLines( new StringReader( input ) ); + } + + public static long countLinesFromFile( File input ) throws IOException + { + return LibvirtXmlDocumentTest.countLines( new FileReader( input ) ); + } + + @Test + @DisplayName( "Read libvirt XML file to String" ) + public void testReadXmlFileToString() throws LibvirtXmlSerializationException, IOException + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + File originalXmlFile = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + + final String readXmlContent = vm.toXml(); + + assertNotNull( readXmlContent ); + + final long lengthReadXmlContent = LibvirtXmlDocumentTest.countLinesFromString( readXmlContent ); + final long lengthOriginalXmlContent = LibvirtXmlDocumentTest.countLinesFromFile( originalXmlFile ); + + assertEquals( lengthOriginalXmlContent, lengthReadXmlContent ); + } + + @Test + @DisplayName( "Read libvirt XML file to file" ) + public void testReadXmlFileToFile() throws LibvirtXmlSerializationException, IOException + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + File originalXmlFile = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + File readXmlFile = LibvirtXmlTestResources.createLibvirtXmlTempFile(); + + vm.toXml( readXmlFile ); + + final String readXmlContent = FileUtils.readFileToString( readXmlFile, StandardCharsets.UTF_8 ); + final String originalXmlContent = FileUtils.readFileToString( originalXmlFile, StandardCharsets.UTF_8 ); + + assertNotNull( readXmlContent ); + + final long lengthReadXmlContent = LibvirtXmlDocumentTest.countLinesFromString( readXmlContent ); + final long lengthOriginalXmlContent = LibvirtXmlDocumentTest.countLinesFromString( originalXmlContent ); + + assertEquals( lengthOriginalXmlContent, lengthReadXmlContent ); + } + + @Test + @DisplayName( "Validate correct libvirt XML file" ) + public void testValidateCorrectXmlFile() + { + Executable validateXmlDocument = () -> { + this.newLibvirtXmlDocumentValidationInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml", "domain.rng" ); + }; + + assertDoesNotThrow( validateXmlDocument ); + } + + @Test + @DisplayName( "Validate incorrect libvirt XML file" ) + public void testValidateIncorrectXmlFile() + { + Executable validateXmlDocument = () -> { + LibvirtXmlDocument doc = this.newLibvirtXmlDocumentValidationInstance( "qemu-kvm_default-ubuntu-20-04-vm-invalid.xml", "domain.rng" ); + doc.validateXml(); + }; + + assertThrows( LibvirtXmlValidationException.class, validateXmlDocument ); + } + + @Test + @DisplayName( "Get non-existent node from libvirt XML file" ) + public void testGetNonExistentElement() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertNull( vm.getRootXmlNode().getXmlElement( "info" ) ); + } + + @Test + @DisplayName( "Set non-existent node in libvirt XML file" ) + public void testSetNonExistentElement() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElement( "info" ); + assertNotNull( vm.getRootXmlNode().getXmlElement( "info" ) ); + } + + @Test + @DisplayName( "Get non-existent element's value in libvirt XML file" ) + public void testGetNonExistentElementValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertNull( vm.getRootXmlNode().getXmlElementValue( "info" ) ); + } + + @Test + @DisplayName( "Set non-existent element's value in libvirt XML file" ) + public void testSetNonExistentElementValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElementValue( "info", "content" ); + assertEquals( "content", vm.getRootXmlNode().getXmlElementValue( "info" ) ); + } + + @Test + @DisplayName( "Get empty element from libvirt XML file" ) + public void testGetEmptyElement() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertNotNull( vm.getRootXmlNode().getXmlElement( "features/acpi" ) ); + } + + @Test + @DisplayName( "Set empty element in libvirt XML file" ) + public void testSetEmptyElement() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElement( "features/acpi" ); + assertNotNull( vm.getRootXmlNode().getXmlElement( "features/acpi" ) ); + } + + @Test + @DisplayName( "Get empty element's value from libvirt XML file" ) + public void testGetEmptyElementValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( EMPTY, vm.getRootXmlNode().getXmlElementValue( "features/acpi" ) ); + } + + @Test + @DisplayName( "Set empty element's value in libvirt XML file" ) + public void testSetEmptyElementValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElementValue( "features/acpi", "content" ); + assertEquals( "content", vm.getRootXmlNode().getXmlElementValue( "features/acpi" ) ); + } + + @Test + @DisplayName( "Get non-existent element's attribute value from libvirt XML file" ) + public void testGetNonExistentElementAttributeValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertNull( vm.getRootXmlNode().getXmlElementAttributeValue( "info", "test" ) ); + } + + @Test + @DisplayName( "Set non-existent element's attribute value from libvirt XML file" ) + public void testSetNonExistentElementAttributeValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElementAttributeValue( "info", "test", "info" ); + assertEquals( "info", vm.getRootXmlNode().getXmlElementAttributeValue( "info", "test" ) ); + } + + @Test + @DisplayName( "Get element's non-existent attribute value from libvirt XML file" ) + public void testGetElementNonExistentAttributeValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertNull( vm.getRootXmlNode().getXmlElementAttributeValue( "features/acpi", "test" ) ); + } + + @Test + @DisplayName( "Set element's non-existent attribute value from libvirt XML file" ) + public void testSetElementNonExistentAttributeValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElementAttributeValue( "features/acpi", "test", "info" ); + assertEquals( "info", vm.getRootXmlNode().getXmlElementAttributeValue( "features/acpi", "test" ) ); + } + + @Test + @DisplayName( "Get element's attribute value from libvirt XML file" ) + public void testGetElementAttributeValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + assertEquals( "partial", vm.getRootXmlNode().getXmlElementAttributeValue( "cpu", "check" ) ); + } + + @Test + @DisplayName( "Set element's attribute value from libvirt XML file" ) + public void testSetElementAttributeValue() + { + LibvirtXmlDocument vm = this.newLibvirtXmlDocumentInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.getRootXmlNode().setXmlElementAttributeValue( "cpu", "check", "full" ); + assertEquals( "full", vm.getRootXmlNode().getXmlElementAttributeValue( "cpu", "check" ) ); + } +} diff --git a/src/test/java/org/openslx/libvirt/xml/LibvirtXmlTestResources.java b/src/test/java/org/openslx/libvirt/xml/LibvirtXmlTestResources.java new file mode 100644 index 0000000..20d2376 --- /dev/null +++ b/src/test/java/org/openslx/libvirt/xml/LibvirtXmlTestResources.java @@ -0,0 +1,40 @@ +package org.openslx.libvirt.xml; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; + +import org.openslx.util.Resources; + +public final class LibvirtXmlTestResources +{ + private static final String LIBVIRT_PREFIX_PATH = Resources.PATH_SEPARATOR + "libvirt"; + private static final String LIBVIRT_PREFIX_PATH_XML = LIBVIRT_PREFIX_PATH + Resources.PATH_SEPARATOR + "xml"; + + private static final String LIBVIRT_TEMP_PREFIX = "libvirt-"; + private static final String LIBVIRT_TEMP_SUFFIX = ".xml"; + + public static File getLibvirtXmlFile( String libvirtXmlFileName ) + { + String libvirtXmlPath = LibvirtXmlTestResources.LIBVIRT_PREFIX_PATH_XML + Resources.PATH_SEPARATOR + + libvirtXmlFileName; + URL libvirtXml = LibvirtXmlTestResources.class.getResource( libvirtXmlPath ); + return new File( libvirtXml.getFile() ); + } + + public static InputStream getLibvirtXmlStream( String libvirtXmlFileName ) + { + String libvirtXmlPath = LibvirtXmlTestResources.LIBVIRT_PREFIX_PATH_XML + Resources.PATH_SEPARATOR + + libvirtXmlFileName; + return LibvirtXmlTestResources.class.getResourceAsStream( libvirtXmlPath ); + } + + public static File createLibvirtXmlTempFile() throws IOException + { + File tempFile = File.createTempFile( LibvirtXmlTestResources.LIBVIRT_TEMP_PREFIX, + LibvirtXmlTestResources.LIBVIRT_TEMP_SUFFIX ); + tempFile.deleteOnExit(); + return tempFile; + } +} diff --git a/src/test/java/org/openslx/util/TarArchiveUtilTest.java b/src/test/java/org/openslx/util/TarArchiveUtilTest.java new file mode 100644 index 0000000..5df5202 --- /dev/null +++ b/src/test/java/org/openslx/util/TarArchiveUtilTest.java @@ -0,0 +1,45 @@ +package org.openslx.util; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.util.TarArchiveUtil.TarArchiveReader; +import org.openslx.util.TarArchiveUtil.TarArchiveWriter; + +public class TarArchiveUtilTest { + + @Test + @DisplayName( "Test creating tgz file" ) + public void testCreateTarGz() throws IOException + { + // dummy content + final String DUMMY_FILENAME = "test"; + final String DUMMY_FILE_DATA = "Hello World"; + + // create targz file with dummy content + ByteArrayOutputStream out = new ByteArrayOutputStream(); + TarArchiveWriter tarArchiveWriter = new TarArchiveWriter(out); + + tarArchiveWriter.writeFile(DUMMY_FILENAME, DUMMY_FILE_DATA); + tarArchiveWriter.close(); + + + // read created targz file, + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + TarArchiveReader tarArchiveReader = new TarArchiveReader(in, true, true); + + assertTrue(tarArchiveReader.hasNextEntry(), "Tar Archive should contain a file"); + assertEquals(DUMMY_FILENAME, tarArchiveReader.getEntryName()); + + String test_string = new String(tarArchiveReader.readCurrentEntry(), StandardCharsets.UTF_8); + assertEquals(DUMMY_FILE_DATA, test_string); + tarArchiveReader.close(); + } +} diff --git a/src/test/java/org/openslx/virtualization/VersionTest.java b/src/test/java/org/openslx/virtualization/VersionTest.java new file mode 100644 index 0000000..21464d9 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/VersionTest.java @@ -0,0 +1,137 @@ +package org.openslx.virtualization; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +public class VersionTest +{ + @Test + @DisplayName( "Test that version is supported in list of versions" ) + public void testVersionIsSupported() + { + final Version version = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + final List<Version> versions = Collections.unmodifiableList( Arrays.asList( + new Version( Short.valueOf( "2" ) ), + new Version( Short.valueOf( "4" ), Short.valueOf( "3" ) ), + new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ), + new Version( Short.valueOf( "1" ), Short.valueOf( "3" ) ) ) ); + + assertTrue( version.isSupported( versions ) ); + } + + @Test + @DisplayName( "Test that version is not supported in list of versions" ) + public void testVersionIsNotSupported() + { + final Version version = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + final List<Version> versions = Collections.unmodifiableList( Arrays.asList( + new Version( Short.valueOf( "2" ) ), + new Version( Short.valueOf( "4" ), Short.valueOf( "3" ) ), + new Version( Short.valueOf( "6" ), Short.valueOf( "9" ) ), + new Version( Short.valueOf( "1" ), Short.valueOf( "3" ) ) ) ); + + assertFalse( version.isSupported( versions ) ); + } + + @Test + @DisplayName( "Test that new version from String is valid" ) + public void testVersionValueOfValid() + { + assertEquals( new Version( Short.valueOf( "52" ) ), Version.valueOf( "52" ) ); + assertEquals( new Version( Short.valueOf( "1" ), Short.valueOf( "34" ) ), Version.valueOf( "1.34" ) ); + } + + @Test + @DisplayName( "Test that new version from String is invalid" ) + public void testVersionValueOfInvalid() + { + assertNull( Version.valueOf( "52." ) ); + assertNull( Version.valueOf( "1.34-release" ) ); + } + + @Test + @DisplayName( "Test that versions are equal" ) + public void testVersionEquals() + { + final Version versionOne = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + final Version versionTwo = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + + assertTrue( versionOne.equals( versionTwo ) ); + assertTrue( versionTwo.equals( versionOne ) ); + } + + @Test + @DisplayName( "Test that versions are not equal" ) + public void testVersionNotEquals() + { + final Version versionOne = new Version( Short.valueOf( "3" ), Short.valueOf( "2" ) ); + final Version versionTwo = new Version( Short.valueOf( "3" ), Short.valueOf( "3" ) ); + + assertFalse( versionOne.equals( versionTwo ) ); + assertFalse( versionTwo.equals( versionOne ) ); + } + + @Test + @DisplayName( "Test that version is smaller than" ) + public void testVersionSmallerThan() + { + final Version versionOne = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + final Version versionTwo = new Version( Short.valueOf( "3" ), Short.valueOf( "2" ) ); + + assertEquals( -1, versionOne.compareTo( versionTwo ) ); + assertEquals( 1, versionTwo.compareTo( versionOne ) ); + } + + @Test + @DisplayName( "Test that version is smaller than with helper method" ) + public void testVersionSmallerThanMethod() + { + final Version versionOne = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + final Version versionTwo = new Version( Short.valueOf( "3" ), Short.valueOf( "2" ) ); + + assertTrue( versionOne.isSmallerThan( versionTwo ) ); + assertFalse( versionTwo.isSmallerThan( versionOne ) ); + } + + @Test + @DisplayName( "Test that version is greater than" ) + public void testVersionGreaterThan() + { + final Version versionOne = new Version( Short.valueOf( "3" ), Short.valueOf( "3" ) ); + final Version versionTwo = new Version( Short.valueOf( "3" ), Short.valueOf( "2" ) ); + + assertEquals( 1, versionOne.compareTo( versionTwo ) ); + assertEquals( -1, versionTwo.compareTo( versionOne ) ); + } + + @Test + @DisplayName( "Test that version is greater than with helper method" ) + public void testVersionGreaterThanMethod() + { + final Version versionOne = new Version( Short.valueOf( "3" ), Short.valueOf( "3" ) ); + final Version versionTwo = new Version( Short.valueOf( "3" ), Short.valueOf( "2" ) ); + + assertTrue( versionOne.isGreaterThan( versionTwo ) ); + assertFalse( versionTwo.isGreaterThan( versionOne ) ); + } + + @Test + @DisplayName( "Test that versions are equal (compareTo)" ) + public void testVersionEqualCompareTo() + { + final Version versionOne = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + final Version versionTwo = new Version( Short.valueOf( "2" ), Short.valueOf( "3" ) ); + + assertEquals( 0, versionOne.compareTo( versionTwo ) ); + assertEquals( 0, versionTwo.compareTo( versionOne ) ); + } +} 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..f8347f4 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java @@ -0,0 +1,479 @@ +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.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +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.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.xml.LibvirtXmlDocumentTest; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.Version; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.ConfigurableOptionGroup; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.EtherType; +import org.openslx.virtualization.configuration.logic.ConfigurationLogicTestUtils; +import org.openslx.virtualization.disk.DiskImage; +import org.openslx.virtualization.disk.DiskImage.ImageFormat; +import org.openslx.virtualization.disk.DiskImageTestResources; +import org.openslx.virtualization.hardware.ConfigurationGroups; + +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 + Configurator.setRootLevel( 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 long lengthUnfilteredXmlConfig = LibvirtXmlDocumentTest.countLinesFromString( unfilteredXmlConfig ); + final long lengthOriginalXmlConfig = LibvirtXmlDocumentTest.countLinesFromString( originalXmlConfig ); + + 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 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 ); + + List<ConfigurableOptionGroup> groups = vmConfig.getConfigurableOptions(); + + for ( ConfigurableOptionGroup group : groups ) { + if ( group.groupIdentifier != ConfigurationGroups.NIC_MODEL ) + continue; + if ( vmLibvirtDomainConfig.getInterfaceDevices().isEmpty() ) { + assertEquals( null, group.getSelected() ); + } else { + assertEquals( Interface.Model.VIRTIO.toString(), group.getSelected().getId() ); + } + } + + 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..4eae06b --- /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.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +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.virtualization.disk.DiskImage.ImageFormat; + +public class VirtualizationConfigurationVirtualBoxTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + Configurator.setRootLevel( 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..09de9f5 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java @@ -0,0 +1,93 @@ +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.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +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 + Configurator.setRootLevel( 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 ); + + ConfigurationLogicTestUtils.assertXmlEqual( 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 ); + + ConfigurationLogicTestUtils.assertXmlEqual( 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 ); + assertTrue( config.getHdds().size() == 1 ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + ConfigurationLogicTestUtils.assertVmxVmwareEqual( 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..772f2f4 --- /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.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +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.virtualization.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 + Configurator.setRootLevel( 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 ); + + ConfigurationLogicTestUtils.assertXmlLibvirtEqual( 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 ); + + ConfigurationLogicTestUtils.assertXmlVirtualBoxEqual( 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 ); + assertTrue( config.getHdds().size() == 1 ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + ConfigurationLogicTestUtils.assertVmxVmwareEqual( 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..57df203 --- /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.logging.log4j.Level; +import org.apache.logging.log4j.core.config.Configurator; +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 + Configurator.setRootLevel( 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 ); + + ConfigurationLogicTestUtils.assertXmlEqual( 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 ); + + ConfigurationLogicTestUtils.assertXmlEqual( 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 ); + assertTrue( config.getHdds().size() == 1 ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + ConfigurationLogicTestUtils.assertVmxVmwareEqual( 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..1b77d03 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java @@ -0,0 +1,34 @@ +package org.openslx.virtualization.configuration.logic; + +import java.io.File; +import java.net.URL; + +import org.openslx.util.Resources; + +public class ConfigurationLogicTestResources +{ + private static final String VMWARE_PREFIX_PATH = Resources.PATH_SEPARATOR + "vmware"; + private static final String VMWARE_PREFIX_PATH_VMX = VMWARE_PREFIX_PATH + Resources.PATH_SEPARATOR + "vmx"; + + private static final String VIRTUALBOX_PREFIX_PATH = Resources.PATH_SEPARATOR + "virtualbox"; + private static final String VIRTUALBOX_PREFIX_PATH_XML = VIRTUALBOX_PREFIX_PATH + Resources.PATH_SEPARATOR + "xml"; + + private static File getFile( String prefixPath, String fileName ) + { + final String filePath = prefixPath + Resources.PATH_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..d085960 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java @@ -0,0 +1,147 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertEquals; +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.ArrayList; +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; +import org.xmlunit.assertj.XmlAssert; + +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 = "<(Machine|HardDisk|Image)(.*)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"; + private static final String REGEX_SOURCE_FILE_PATHS = "(<source.*file=\")([^\"]*)"; + + 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 void assertXmlEqual( String expectedXml, String actualXml ) throws AssertionError + { + XmlAssert.assertThat( actualXml ).and( expectedXml ).ignoreComments().areIdentical(); + } + + private static String removeSourceFilePaths( String content ) + { + final Pattern patternSourceFilePaths = Pattern.compile( ConfigurationLogicTestUtils.REGEX_SOURCE_FILE_PATHS ); + final Matcher matcherSourceFilePathsContent = patternSourceFilePaths.matcher( content ); + + // replace all source file paths with the empty String + return matcherSourceFilePathsContent.replaceAll( "$1" ); + } + + private 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( "<$1$200000000-0000-0000-0000-000000000000" ); + } + + public static void assertXmlLibvirtEqual( String expectedXml, String actualXml ) throws AssertionError + { + // replace all source file paths with the empty String + final String filteredXml1 = ConfigurationLogicTestUtils.removeSourceFilePaths( expectedXml ); + final String filteredXml2 = ConfigurationLogicTestUtils.removeSourceFilePaths( actualXml ); + + ConfigurationLogicTestUtils.assertXmlEqual( filteredXml1, filteredXml2 ); + } + + public static void assertXmlVirtualBoxEqual( String expectedXml, String actualXml ) throws AssertionError + { + // replace all UUIDs with the zero UUID in the generated XML as it's random + final String actualXmlFiltered = ConfigurationLogicTestUtils.removeUuid( actualXml ); + + ConfigurationLogicTestUtils.assertXmlEqual( expectedXml, actualXmlFiltered ); + } + + public static void assertVmxVmwareEqual( String expectedVmx, String actualVmx ) throws AssertionError + { + final BufferedReader bfrVmx1 = new BufferedReader( new StringReader( expectedVmx ) ); + final BufferedReader bfrVmx2 = new BufferedReader( new StringReader( actualVmx ) ); + final List<String> linesVmx1 = bfrVmx1.lines().collect( Collectors.toList() ); + final List<String> linesVmx2 = bfrVmx2.lines().collect( Collectors.toList() ); + + // check output size first + if ( linesVmx1.size() != linesVmx2.size() ) { + // create list of items that are expected but missing in the actual output + final List<String> missingItems; + final String missingItemsDesc; + + if ( linesVmx1.size() > linesVmx2.size() ) { + missingItemsDesc = "The following items are expected but missing in the actual output"; + missingItems = new ArrayList<String>( linesVmx1 ); + missingItems.removeAll( linesVmx2 ); + } else { + missingItemsDesc = "The following items are not expected but occuring in the actual output"; + missingItems = new ArrayList<String>( linesVmx2 ); + missingItems.removeAll( linesVmx1 ); + } + + throw new AssertionError( String.format( + "VMX output size is not satisfied: Expected %d lines, but output has %d lines!\n" + + "%s:\n" + + "%s", + linesVmx1.size(), linesVmx2.size(), missingItemsDesc, missingItems ) ); + } + + // check the content of the output line by line + assertEquals( linesVmx1, linesVmx2 ); + } +} diff --git a/src/test/java/org/openslx/virtualization/disk/DiskImageQcow2Test.java b/src/test/java/org/openslx/virtualization/disk/DiskImageQcow2Test.java new file mode 100644 index 0000000..c6a294c --- /dev/null +++ b/src/test/java/org/openslx/virtualization/disk/DiskImageQcow2Test.java @@ -0,0 +1,221 @@ +package org.openslx.virtualization.disk; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.io.IOException; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.virtualization.Version; +import org.openslx.virtualization.disk.DiskImage.ImageFormat; + +public class DiskImageQcow2Test +{ + @Test + @DisplayName( "Test detection of default QCOW2 disk image" ) + public void testQcow2DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of compressed, 16384 byte cluster QCOW2 disk image with extended L2 tables" ) + public void testQcow2DetectionL2Compressed16384DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-on_l2-on.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of compressed, 16384 byte cluster QCOW2 disk image without extended L2 tables" ) + public void testQcow2DetectionNonL2Compressed16384DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-on_l2-off.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of non-compressed, 16384 byte cluster QCOW2 disk image with extended L2 tables" ) + public void testQcow2DetectionL2NonCompressed16384DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-off_l2-on.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of non-compressed, 16384 byte cluster QCOW2 disk image without extended L2 tables" ) + public void testQcow2DetectionNonL2NonCompressed16384DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-off_l2-off.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of compressed, 65536 byte cluster QCOW2 disk image with extended L2 tables" ) + public void testQcow2DetectionL2Compressed65536DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-on_l2-on.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of compressed, 65536 byte cluster QCOW2 disk image without extended L2 tables" ) + public void testQcow2DetectionNonL2Compressed65536DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-on_l2-off.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of non-compressed, 65536 byte cluster QCOW2 disk image with extended L2 tables" ) + public void testQcow2DetectionL2NonCompressed65536DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-off_l2-on.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of non-compressed, 65536 byte cluster QCOW2 disk image without extended L2 tables" ) + public void testQcow2DetectionNonL2NonCompressed65536DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-off_l2-off.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of compressed, 2097152 byte cluster QCOW2 disk image with extended L2 tables" ) + public void testQcow2DetectionL2Compressed2097152DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-on_l2-on.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of compressed, 2097152 byte cluster QCOW2 disk image without extended L2 tables" ) + public void testQcow2DetectionNonL2Compressed2097152DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-on_l2-off.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of non-compressed, 2097152 byte cluster QCOW2 disk image with extended L2 tables" ) + public void testQcow2DetectionL2NonCompressed2097152DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-off_l2-on.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of non-compressed, 2097152 byte cluster QCOW2 disk image without extended L2 tables" ) + public void testQcow2DetectionNonL2NonCompressed2097152DiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage + .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-off_l2-off.qcow2" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + + assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/disk/DiskImageTest.java b/src/test/java/org/openslx/virtualization/disk/DiskImageTest.java new file mode 100644 index 0000000..9293a90 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/disk/DiskImageTest.java @@ -0,0 +1,19 @@ +package org.openslx.virtualization.disk; + +import java.io.IOException; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +public class DiskImageTest +{ + @Test + @DisplayName( "Test of invalid disk image" ) + public void testInvalidDiskImage() throws IOException + { + Assertions.assertThrows( DiskImageException.class, () -> { + DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.invalid" ) ); + } ); + } +} diff --git a/src/test/java/org/openslx/virtualization/disk/DiskImageTestResources.java b/src/test/java/org/openslx/virtualization/disk/DiskImageTestResources.java new file mode 100644 index 0000000..0b283a7 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/disk/DiskImageTestResources.java @@ -0,0 +1,18 @@ +package org.openslx.virtualization.disk; + +import java.io.File; +import java.net.URL; + +import org.openslx.util.Resources; + +public class DiskImageTestResources +{ + private static final String DISK_PREFIX_PATH = Resources.PATH_SEPARATOR + "disk"; + + public static File getDiskFile( String diskFileName ) + { + String diskPath = DiskImageTestResources.DISK_PREFIX_PATH + Resources.PATH_SEPARATOR + diskFileName; + URL disk = DiskImageTestResources.class.getResource( diskPath ); + return new File( disk.getFile() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/disk/DiskImageVdiTest.java b/src/test/java/org/openslx/virtualization/disk/DiskImageVdiTest.java new file mode 100644 index 0000000..06307fa --- /dev/null +++ b/src/test/java/org/openslx/virtualization/disk/DiskImageVdiTest.java @@ -0,0 +1,44 @@ +package org.openslx.virtualization.disk; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.io.IOException; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.virtualization.Version; +import org.openslx.virtualization.disk.DiskImage.ImageFormat; + +public class DiskImageVdiTest +{ + @Test + @DisplayName( "Test detection of default VDI disk image" ) + public void testVdiDiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.vdi" ) ); + final Version imageVersion = new Version( Short.valueOf( "1" ), Short.valueOf( "1" ) ); + + assertEquals( ImageFormat.VDI.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNotNull( image.getDescription() ); + } + + @Test + @DisplayName( "Test detection of VDI disk image snapshot" ) + public void testVdiDiskImageSnapshot() throws DiskImageException, IOException + { + final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default_snapshot.vdi" ) ); + final Version imageVersion = new Version( Short.valueOf( "1" ), Short.valueOf( "1" ) ); + + assertEquals( ImageFormat.VDI.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( true, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNotNull( image.getDescription() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/disk/DiskImageVmdkTest.java b/src/test/java/org/openslx/virtualization/disk/DiskImageVmdkTest.java new file mode 100644 index 0000000..5b3cccf --- /dev/null +++ b/src/test/java/org/openslx/virtualization/disk/DiskImageVmdkTest.java @@ -0,0 +1,111 @@ +package org.openslx.virtualization.disk; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.io.IOException; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.virtualization.Version; +import org.openslx.virtualization.disk.DiskImage.ImageFormat; + +public class DiskImageVmdkTest +{ + @Test + @DisplayName( "Test detection of default VMDK disk image" ) + public void testVmdkDiskImage() throws DiskImageException, IOException + { + final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.vmdk" ) ); + final Version imageVersion = new Version( Short.valueOf( "1" ) ); + final Version imageHwVersion = new Version( Short.valueOf( "18" ) ); + + assertEquals( ImageFormat.VMDK.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + + // test special features of the VMDK disk image format + final DiskImageVmdk vmdkImage = DiskImageVmdk.class.cast( image ); + assertEquals( imageHwVersion, vmdkImage.getHwVersion() ); + } + + @Test + @DisplayName( "Test detection of VMDK disk image (type 0: single growable virtual disk)" ) + public void testVmdkDiskImageType0() throws DiskImageException, IOException + { + final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t0.vmdk" ) ); + final Version imageVersion = new Version( Short.valueOf( "1" ) ); + final Version imageHwVersion = new Version( Short.valueOf( "18" ) ); + + assertEquals( ImageFormat.VMDK.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( false, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + + // test special features of the VMDK disk image format + final DiskImageVmdk vmdkImage = DiskImageVmdk.class.cast( image ); + assertEquals( imageHwVersion, vmdkImage.getHwVersion() ); + } + + @Test + @DisplayName( "Test detection of VMDK disk image (type 1: growable virtual disk split into multiple files)" ) + public void testVmdkDiskImageType1() throws DiskImageException, IOException + { + Assertions.assertThrows( DiskImageException.class, () -> { + DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t1.vmdk" ) ); + } ); + } + + @Test + @DisplayName( "Test detection of VMDK disk image (type 2: preallocated virtual disk)" ) + public void testVmdkDiskImageType2() throws DiskImageException, IOException + { + Assertions.assertThrows( DiskImageException.class, () -> { + DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t2.vmdk" ) ); + } ); + } + + @Test + @DisplayName( "Test detection of VMDK disk image (type 3: preallocated virtual disk split into multiple files)" ) + public void testVmdkDiskImageType3() throws DiskImageException, IOException + { + Assertions.assertThrows( DiskImageException.class, () -> { + DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t3.vmdk" ) ); + } ); + } + + @Test + @DisplayName( "Test detection of VMDK disk image (type 4: preallocated ESX-type virtual disk)" ) + public void testVmdkDiskImageType4() throws DiskImageException, IOException + { + Assertions.assertThrows( DiskImageException.class, () -> { + DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t4.vmdk" ) ); + } ); + } + + @Test + @DisplayName( "Test detection of VMDK disk image (type 5: compressed disk optimized for streaming)" ) + public void testVmdkDiskImageType5() throws DiskImageException, IOException + { + final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t5.vmdk" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); + final Version imageHwVersion = new Version( Short.valueOf( "18" ) ); + + assertEquals( ImageFormat.VMDK.toString(), image.getFormat().toString() ); + assertEquals( true, image.isStandalone() ); + assertEquals( false, image.isSnapshot() ); + assertEquals( true, image.isCompressed() ); + assertEquals( imageVersion, image.getVersion() ); + assertNull( image.getDescription() ); + + // test special features of the VMDK disk image format + final DiskImageVmdk vmdkImage = DiskImageVmdk.class.cast( image ); + assertEquals( imageHwVersion, vmdkImage.getHwVersion() ); + } +} |