diff options
Diffstat (limited to 'src/test/java')
15 files changed, 1412 insertions, 107 deletions
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..e7d7651 --- /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.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.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 + LogManager.getRootLogger().setLevel( 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 index a604b21..e1fb73b 100644 --- a/src/test/java/org/openslx/libvirt/domain/DomainTest.java +++ b/src/test/java/org/openslx/libvirt/domain/DomainTest.java @@ -13,6 +13,7 @@ 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; @@ -110,6 +111,14 @@ public class DomainTest } @Test + @DisplayName( "Get VM libosinfo operating system identifier in libvirt XML file" ) + public void testGetLibOsInfoOsId() + { + Domain vm = this.newDomainInstance( "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() { @@ -178,6 +187,57 @@ public class DomainTest } @Test + @DisplayName( "Get VM's OS type from libvirt XML file" ) + public void testGetOsType() + { + Domain vm = this.newDomainInstance( "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 = this.newDomainInstance( "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 = this.newDomainInstance( "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 = this.newDomainInstance( "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 = this.newDomainInstance( "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 = this.newDomainInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); + vm.setOsMachine( "pc" ); + assertEquals( "pc", vm.getOsMachine() ); + } + + @Test @DisplayName( "Get VM CPU model from libvirt XML file" ) public void testGetCpuModel() { @@ -229,11 +289,28 @@ public class DomainTest } @Test + @DisplayName( "Get VM emulator binary from libvirt XML file" ) + public void testGetDevicesEmulator() + { + Domain vm = this.newDomainInstance( "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 = this.newDomainInstance( "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 = this.newDomainInstance( "qemu-kvm_default-ubuntu-20-04-vm.xml" ); - assertEquals( 21, vm.getDevices().size() ); + assertEquals( 22, vm.getDevices().size() ); } @Test @@ -253,6 +330,14 @@ public class DomainTest } @Test + @DisplayName( "Get all VM file system devices from libvirt XML file" ) + public void testGetFileSystemDevices() + { + Domain vm = this.newDomainInstance( "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() { @@ -277,6 +362,22 @@ public class DomainTest } @Test + @DisplayName( "Get all VM parallel port devices from libvirt XML file" ) + public void testGetParallelDevices() + { + Domain vm = this.newDomainInstance( "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 = this.newDomainInstance( "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() { 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/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/vm/QemuMetaDataTest.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java index 3217fda..1cc7841 100644 --- a/src/test/java/org/openslx/vm/QemuMetaDataTest.java +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java @@ -1,7 +1,9 @@ -package org.openslx.vm; +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; @@ -23,6 +25,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; +import org.openslx.bwlp.thrift.iface.OperatingSystem; import org.openslx.libvirt.domain.Domain; import org.openslx.libvirt.domain.device.ControllerUsb; import org.openslx.libvirt.domain.device.DiskCdrom; @@ -31,20 +34,24 @@ import org.openslx.libvirt.domain.device.DiskStorage; import org.openslx.libvirt.domain.device.Interface; import org.openslx.libvirt.domain.device.Sound; import org.openslx.libvirt.xml.LibvirtXmlTestResources; -import org.openslx.vm.VmMetaData.EtherType; -import org.openslx.vm.VmMetaData.EthernetDevType; -import org.openslx.vm.VmMetaData.SoundCardType; -import org.openslx.vm.VmMetaData.UsbSpeed; +import org.openslx.virtualization.Version; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.EtherType; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.EthernetDevType; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.SoundCardType; +import org.openslx.virtualization.configuration.VirtualizationConfiguration.UsbSpeed; +import org.openslx.virtualization.configuration.logic.ConfigurationLogicTestUtils; import org.openslx.vm.disk.DiskImage; import org.openslx.vm.disk.DiskImageTestResources; import org.openslx.vm.disk.DiskImage.ImageFormat; -public class QemuMetaDataTest +public class VirtualizationConfigurationQemuTest { - private static Domain getPrivateDomainFromQemuMetaData( QemuMetaData qemuMetadata ) + 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 = QemuMetaData.class.getDeclaredField( "vmConfig" ); + Field privateDomainField = VirtualizationConfigurationQemu.class.getDeclaredField( "vmConfig" ); privateDomainField.setAccessible( true ); return Domain.class.cast( privateDomainField.get( qemuMetadata ) ); } @@ -58,65 +65,119 @@ public class QemuMetaDataTest @Test @DisplayName( "Test display name from VM configuration" ) - public void testQemuMetaDataGetDisplayName() throws UnsupportedVirtualizerFormatException, IOException + public void testQemuMetaDataGetDisplayName() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + 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 UnsupportedVirtualizerFormatException, IOException + public void testQemuMetaDataIsMachineSnapshot() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + 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 UnsupportedVirtualizerFormatException, IOException + public void testQemuMetaDataGetSupportedImageFormats() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - final List<DiskImage.ImageFormat> supportedImageFormats = vmConfig.getSupportedImageFormats(); + 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 UnsupportedVirtualizerFormatException, IOException + public void testQemuMetaDataGetHdds() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - final List<VmMetaData.HardDisk> hdds = vmConfig.getHdds(); + 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 UnsupportedVirtualizerFormatException, IOException + public void testQemuMetaDataGetDefinitionArray() + throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - final String unfilteredXmlConfig = new String( vmConfig.getDefinitionArray(), StandardCharsets.UTF_8 ); + final String unfilteredXmlConfig = new String( vmConfig.getConfigurationAsByteArray(), StandardCharsets.UTF_8 ); final String originalXmlConfig = FileUtils.readFileToString( file, StandardCharsets.UTF_8 ); assertNotNull( unfilteredXmlConfig ); @@ -125,48 +186,31 @@ public class QemuMetaDataTest final int lengthOriginalXmlConfig = originalXmlConfig.split( System.lineSeparator() ).length; assertEquals( lengthOriginalXmlConfig, lengthUnfilteredXmlConfig ); - } - @Test - @DisplayName( "Test output of filtered VM configuration" ) - public void testQemuMetaDataGetFilteredDefinitionArray() throws UnsupportedVirtualizerFormatException, IOException - { - File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); - - final int numberOfDeletedElements = 4; - - final String filteredXmlConfig = new String( vmConfig.getFilteredDefinitionArray(), StandardCharsets.UTF_8 ); - final String originalXmlConfig = FileUtils.readFileToString( file, StandardCharsets.UTF_8 ); - - assertNotNull( filteredXmlConfig ); - - final int lengthFilteredXmlConfig = filteredXmlConfig.split( System.lineSeparator() ).length; - final int lengthOriginalXmlConfig = originalXmlConfig.split( System.lineSeparator() ).length; - - assertEquals( lengthOriginalXmlConfig, lengthFilteredXmlConfig + numberOfDeletedElements ); + 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 UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" ); File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numHddsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskStorageDevices().size(); - final int numHddsQemuMetaDataBeforeAdd = vmConfig.hdds.size(); + final int numHddsQemuMetaDataBeforeAdd = vmConfig.getHdds().size(); vmConfig.addHddTemplate( diskFile, null, null ); final int numHddsLibvirtDomainXmlAfterAdd = vmLibvirtDomainConfig.getDiskStorageDevices().size(); - final int numHddsQemuMetaDataAfterAdd = vmConfig.hdds.size(); + final int numHddsQemuMetaDataAfterAdd = vmConfig.getHdds().size(); assertTrue( numHddsLibvirtDomainXmlBeforeAdd == numHddsQemuMetaDataBeforeAdd ); assertTrue( numHddsLibvirtDomainXmlAfterAdd == numHddsQemuMetaDataAfterAdd ); @@ -184,20 +228,23 @@ public class QemuMetaDataTest 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 UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" ); File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numCdromsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size(); @@ -210,19 +257,22 @@ public class QemuMetaDataTest 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 UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numCdromsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size(); @@ -234,21 +284,24 @@ public class QemuMetaDataTest assertTrue( numCdromsLibvirtDomainXmlAfterAdd > 0 ); DiskCdrom addedCdromDevice = vmLibvirtDomainConfig.getDiskCdromDevices().get( 0 ); - assertEquals( QemuMetaData.CDROM_DEFAULT_PHYSICAL_DRIVE, addedCdromDevice.getStorageSource() ); + 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 UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" ); File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numFloppiesLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskFloppyDevices().size(); @@ -262,36 +315,42 @@ public class QemuMetaDataTest 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 UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); vmConfig.addCpuCoreCount( coreCount ); assertEquals( coreCount, vmLibvirtDomainConfig.getVCpu() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); } @ParameterizedTest @DisplayName( "Test get sound card from VM configuration" ) @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-sound.xml" } ) public void testQemuMetaDataGetSoundCardType( String xmlFileName ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); SoundCardType soundCardType = vmConfig.getSoundCard(); @@ -300,19 +359,22 @@ public class QemuMetaDataTest } else { assertEquals( SoundCardType.HD_AUDIO, soundCardType ); } + + assertDoesNotThrow( () -> vmConfig.validate() ); } @ParameterizedTest @DisplayName( "Test set sound card in VM configuration" ) @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-sound.xml" } ) public void testQemuMetaDataSetSoundCardType( String xmlFileName ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numSoundDevsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getSoundDevices().size(); @@ -325,19 +387,22 @@ public class QemuMetaDataTest Sound addedSoundDevice = vmLibvirtDomainConfig.getSoundDevices().get( 0 ); assertEquals( Sound.Model.SB16, addedSoundDevice.getModel() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); } @ParameterizedTest @DisplayName( "Test get ethernet device type from VM configuration" ) @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-nic.xml" } ) public void testQemuMetaDataGetEthernetDevType( String xmlFileName ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); EthernetDevType ethernetDeviceType = vmConfig.getEthernetDevType( 0 ); @@ -346,19 +411,22 @@ public class QemuMetaDataTest } else { assertEquals( EthernetDevType.PARAVIRT, ethernetDeviceType ); } + + assertDoesNotThrow( () -> vmConfig.validate() ); } @ParameterizedTest @DisplayName( "Test set ethernet device type in VM configuration" ) @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-nic.xml" } ) public void testQemuMetaDataSetEthernetDevType( String xmlFileName ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); vmConfig.setEthernetDevType( 0, EthernetDevType.E1000E ); @@ -366,19 +434,22 @@ public class QemuMetaDataTest Interface addedEthernetDevice = vmLibvirtDomainConfig.getInterfaceDevices().get( 0 ); assertEquals( Interface.Model.E1000E, addedEthernetDevice.getModel() ); } + + assertDoesNotThrow( () -> vmConfig.validate() ); } @ParameterizedTest @DisplayName( "Test get maximal USB speed from VM configuration" ) @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-usb.xml" } ) public void testQemuMetaDataGetMaxUsbSpeed( String xmlFileName ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); UsbSpeed maxUsbSpeed = vmConfig.getMaxUsbSpeed(); @@ -387,19 +458,22 @@ public class QemuMetaDataTest } else { assertEquals( UsbSpeed.USB3_0, maxUsbSpeed ); } + + assertDoesNotThrow( () -> vmConfig.validate() ); } @ParameterizedTest @DisplayName( "Test set maximal USB speed in VM configuration" ) @ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-usb.xml" } ) public void testQemuMetaDataSetMaxUsbSpeed( String xmlFileName ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numUsbControllersLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getUsbControllerDevices().size(); @@ -412,6 +486,8 @@ public class QemuMetaDataTest ControllerUsb addedUsbControllerDevice = vmLibvirtDomainConfig.getUsbControllerDevices().get( 0 ); assertEquals( ControllerUsb.Model.ICH9_EHCI1, addedUsbControllerDevice.getModel() ); + + assertDoesNotThrow( () -> vmConfig.validate() ); } static Stream<Arguments> configAndEthernetTypeProvider() @@ -429,13 +505,14 @@ public class QemuMetaDataTest @DisplayName( "Test add ethernet device to VM configuration" ) @MethodSource( "configAndEthernetTypeProvider" ) public void testQemuMetaDataAddEthernet( String xmlFileName, EtherType ethernetType ) - throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException, + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); - QemuMetaData vmConfig = new QemuMetaData( null, file ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); - Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig ); + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); final int numEthernetDevsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getInterfaceDevices().size(); @@ -451,18 +528,77 @@ public class QemuMetaDataTest case BRIDGED: assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() ); assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() ); - assertEquals( QemuMetaData.NETWORK_DEFAULT_BRIDGE, addedEthernetDevice.getSource() ); + assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_LAN_DEFAULT, addedEthernetDevice.getSource() ); break; case HOST_ONLY: - assertEquals( Interface.Type.NETWORK, addedEthernetDevice.getType() ); + assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() ); assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() ); - assertEquals( QemuMetaData.NETWORK_DEFAULT_HOST_ONLY, addedEthernetDevice.getSource() ); + assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_HOST_ONLY_DEFAULT, + addedEthernetDevice.getSource() ); break; case NAT: - assertEquals( Interface.Type.NETWORK, addedEthernetDevice.getType() ); + assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() ); assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() ); - assertEquals( QemuMetaData.NETWORK_DEFAULT_NAT, addedEthernetDevice.getSource() ); + assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_NAT_DEFAULT, addedEthernetDevice.getSource() ); break; } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test get virtualizer HW version from VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm-old-os.xml", "qemu-kvm_default-archlinux-vm-no-os.xml" } ) + public void testQemuMetaDataGetVirtualizerVersion( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final Version machineVersion = vmConfig.getVirtualizerVersion(); + + if ( vmLibvirtDomainConfig.getOsMachine() == null ) { + assertNull( machineVersion ); + } else { + assertEquals( new Version( Short.valueOf( "3" ), Short.valueOf( "1" ) ), machineVersion ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); + } + + @ParameterizedTest + @DisplayName( "Test set virtualizer HW version in VM configuration" ) + @ValueSource( strings = { "qemu-kvm_default-archlinux-vm-old-os.xml", "qemu-kvm_default-archlinux-vm-no-os.xml" } ) + public void testQemuMetaDataSetVirtualizerVersion( String xmlFileName ) + throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException, + IllegalArgumentException, IllegalAccessException + { + File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName ); + VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file ); + + final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest + .getPrivateDomainFromQemuMetaData( vmConfig ); + + final String originalOsMachine = vmLibvirtDomainConfig.getOsMachine(); + if ( originalOsMachine != null ) { + assertEquals( "pc-q35-3.1", originalOsMachine ); + } + + final Version modifiedVersion = new Version( Short.valueOf( "4" ), Short.valueOf( "1" ) ); + vmConfig.setVirtualizerVersion( modifiedVersion ); + + final String modifiedOsMachine = vmLibvirtDomainConfig.getOsMachine(); + if ( modifiedOsMachine == null ) { + assertNull( vmConfig.getVirtualizerVersion() ); + } else { + assertEquals( modifiedVersion, vmConfig.getVirtualizerVersion() ); + assertEquals( "pc-q35-4.1", modifiedOsMachine ); + } + + assertDoesNotThrow( () -> vmConfig.validate() ); } } diff --git a/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationTestResources.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationTestResources.java new file mode 100644 index 0000000..4dfd0b7 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationTestResources.java @@ -0,0 +1,18 @@ +package org.openslx.virtualization.configuration; + +import java.io.File; + +import org.openslx.virtualization.configuration.logic.ConfigurationLogicTestResources; + +public class VirtualizationConfigurationTestResources +{ + public static File getVmwareVmxFile( String vmwareVmxFileName ) + { + return ConfigurationLogicTestResources.getVmwareVmxFile( vmwareVmxFileName ); + } + + public static File getVirtualBoxXmlFile( String virtualBoxXmlFileName ) + { + return ConfigurationLogicTestResources.getVirtualBoxXmlFile( virtualBoxXmlFileName ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBoxTest.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBoxTest.java new file mode 100644 index 0000000..597fffb --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBoxTest.java @@ -0,0 +1,143 @@ +package org.openslx.virtualization.configuration; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +import java.io.File; +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.openslx.virtualization.Version; +import org.openslx.vm.disk.DiskImage.ImageFormat; + +public class VirtualizationConfigurationVirtualBoxTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @ParameterizedTest + @DisplayName( "Test version from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetConfigurationVersion( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + assertEquals( configVersion, vmConfig.getConfigurationVersion() ); + } + + @ParameterizedTest + @DisplayName( "Test display name from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetDisplayName( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final String displayName = vmConfig.getDisplayName(); + + assertEquals( VirtualizationConfigurationVirtualBoxTest.getVmName( name, configVersion ), displayName ); + } + + @ParameterizedTest + @DisplayName( "Test machine snapshot state from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxIsMachineSnapshot( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final boolean isVmSnapshot = vmConfig.isMachineSnapshot(); + + assertFalse( isVmSnapshot ); + } + + @ParameterizedTest + @DisplayName( "Test supported image formats from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetSupportedImageFormats( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final List<ImageFormat> supportedImageFormats = vmConfig.getVirtualizer().getSupportedImageFormats(); + + assertNotNull( supportedImageFormats ); + assertEquals( 1, supportedImageFormats.size() ); + assertTrue( supportedImageFormats.containsAll( Arrays.asList( ImageFormat.VDI ) ) ); + } + + @ParameterizedTest + @DisplayName( "Test output of HDDs from VM configuration" ) + @MethodSource( "configAndVersionProvider" ) + public void testVirtualizationConfigurationVirtualBoxGetHdds( String name, String configFileName, + Version configVersion ) + throws IOException, VirtualizationConfigurationException + { + final File configFile = VirtualizationConfigurationTestResources.getVirtualBoxXmlFile( configFileName ); + final VirtualizationConfigurationVirtualBox vmConfig = new VirtualizationConfigurationVirtualBox( null, + configFile ); + + final List<VirtualizationConfiguration.HardDisk> hdds = vmConfig.getHdds(); + + final String imageFileName = VirtualizationConfigurationVirtualBoxTest.getVmName( name, configVersion ) + ".vdi"; + + assertNotNull( hdds ); + assertEquals( 1, hdds.size() ); + assertEquals( imageFileName, hdds.get( 0 ).diskImage ); + } + + static String getVmName( String name, Version version ) + { + return name + "_" + version.toString().replace( '.', '-' ); + } + + static Stream<Arguments> configAndVersionProvider() + { + return Stream.of( + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-15.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "15" ) ) ), + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-16.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "16" ) ) ), + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-17.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "17" ) ) ), + arguments( "ubuntu", "virtualbox_default-ubuntu_v1-18.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "18" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-15.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "15" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-16.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "16" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-17.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "17" ) ) ), + arguments( "windows-7", "virtualbox_default-windows-7_v1-18.vbox", + new Version( Short.valueOf( "1" ), Short.valueOf( "18" ) ) ) ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java new file mode 100644 index 0000000..f078b5e --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModClientToDozModServerTest.java @@ -0,0 +1,92 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; +import org.openslx.virtualization.configuration.data.ConfigurationDataDozModClientToDozModServer; +import org.openslx.virtualization.configuration.transformation.TransformationException; + +public class ConfigurationLogicDozModClientToDozModServerTest +{ + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-client and a dozmod-server for Libvirt/QEMU configuration" ) + public void testConfigurationLogicDozModClientToDozModServerLibvirt() throws TransformationException + { + final String inputConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm.xml"; + final String expectedConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-privacy.xml"; + final File inputConfig = LibvirtXmlTestResources.getLibvirtXmlFile( inputConfigFileName ); + final File expectedConfig = LibvirtXmlTestResources.getLibvirtXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-client and a dozmod-server for VirtualBox configuration" ) + public void testConfigurationLogicDozModClientToDozModServerVirtualBox() throws TransformationException + { + final String inputConfigFileName = "virtualbox_default-ubuntu.vbox"; + final String expectedConfigFileName = "virtualbox_default-ubuntu_transform-privacy.vbox"; + final File inputConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + + // do not validate the VirtualBox configuration afterwards, since the inserted + // place holders do not match valid primitive values from the XML schema + //assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-client and a dozmod-server for VMware configuration" ) + public void testConfigurationLogicDozModClientToDozModServerVmware() throws TransformationException + { + final String inputConfigFileName = "vmware-player_default-ubuntu.vmx"; + final String expectedConfigFileName = "vmware-player_default-ubuntu_transform-privacy.vmx"; + final File inputConfig = ConfigurationLogicTestResources.getVmwareVmxFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVmwareVmxFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModClientToDozModServer logic = new ConfigurationLogicDozModClientToDozModServer(); + + logic.apply( config, new ConfigurationDataDozModClientToDozModServer() ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToDozModClientTest.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToDozModClientTest.java new file mode 100644 index 0000000..96180ed --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToDozModClientTest.java @@ -0,0 +1,108 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.bwlp.thrift.iface.OperatingSystem; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; +import org.openslx.virtualization.configuration.data.ConfigurationDataDozModServerToDozModClient; +import org.openslx.virtualization.configuration.transformation.TransformationException; +import org.openslx.vm.disk.DiskImageTestResources; + +public class ConfigurationLogicDozModServerToDozModClientTest +{ + private static final String DEFAULT_DISPLAY_NAME = "Test"; + private static final File DEFAULT_DISK_IMAGE = DiskImageTestResources.getDiskFile( "image-default.vmdk" ); + private static final OperatingSystem DEFAULT_GUEST_OS = null; + private static final String DEFAULT_VIRTUALIZER_ID = null; + private static final int DEFAULT_TOTAL_MEMORY = 4096; + + private static final ConfigurationDataDozModServerToDozModClient DEFAULT_CONFIG_DATA = new ConfigurationDataDozModServerToDozModClient( + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_DISPLAY_NAME, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_DISK_IMAGE, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_GUEST_OS, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_VIRTUALIZER_ID, + ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_TOTAL_MEMORY ); + + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a dozmod-client for Libvirt/QEMU configuration" ) + public void testConfigurationLogicDozModServerToDozModClientLibvirt() throws TransformationException + { + final String inputConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-privacy.xml"; + final String expectedConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-editable.xml"; + final File inputConfig = LibvirtXmlTestResources.getLibvirtXmlFile( inputConfigFileName ); + final File expectedConfig = LibvirtXmlTestResources.getLibvirtXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a dozmod-client for VirtualBox configuration" ) + public void testConfigurationLogicDozModServerToDozModClientVirtualBox() throws TransformationException + { + final String inputConfigFileName = "virtualbox_default-ubuntu_transform-privacy.vbox"; + final String expectedConfigFileName = "virtualbox_default-ubuntu_transform-editable.vbox"; + final File inputConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( + ConfigurationLogicTestUtils.isVirtualBoxContentEqual( expectedTransformedConfig, transformedConfig ) ); + + // do not validate the VirtualBox configuration afterwards, since the inserted network configuration + // leads to an invalid DOM although the created output after the transformation is as expected + //assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between dozmod-server and a dozmod-client for VMware configuration" ) + public void testConfigurationLogicDozModServerToDozModClientVmware() throws TransformationException + { + final String inputConfigFileName = "vmware-player_default-ubuntu_transform-privacy.vmx"; + final String expectedConfigFileName = "vmware-player_default-ubuntu_transform-editable.vmx"; + final File inputConfig = ConfigurationLogicTestResources.getVmwareVmxFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVmwareVmxFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToDozModClient logic = new ConfigurationLogicDozModServerToDozModClient(); + + logic.apply( config, ConfigurationLogicDozModServerToDozModClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToStatelessClientTest.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToStatelessClientTest.java new file mode 100644 index 0000000..6c87526 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicDozModServerToStatelessClientTest.java @@ -0,0 +1,102 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; + +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.openslx.libvirt.xml.LibvirtXmlTestResources; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; +import org.openslx.virtualization.configuration.data.ConfigurationDataDozModServerToStatelessClient; +import org.openslx.virtualization.configuration.transformation.TransformationException; + +public class ConfigurationLogicDozModServerToStatelessClientTest +{ + private static final String DEFAULT_DISPLAY_NAME = "Test"; + private static final String DEFAULT_OS_ID = null; + private static final boolean DEFAULT_HAS_USB_ACCESS = true; + + private static final ConfigurationDataDozModServerToStatelessClient DEFAULT_CONFIG_DATA = new ConfigurationDataDozModServerToStatelessClient( + ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_DISPLAY_NAME, + ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_OS_ID, + ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_HAS_USB_ACCESS ); + + @BeforeAll + public static void setUp() + { + // disable logging with log4j + LogManager.getRootLogger().setLevel( Level.OFF ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a stateless client for Libvirt/QEMU configuration" ) + public void testConfigurationLogicDozModServerToStatelessClientLibvirt() throws TransformationException + { + final String inputConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-privacy.xml"; + final String expectedConfigFileName = "qemu-kvm_default-ubuntu-20-04-vm_transform-non-persistent.xml"; + final File inputConfig = LibvirtXmlTestResources.getLibvirtXmlFile( inputConfigFileName ); + final File expectedConfig = LibvirtXmlTestResources.getLibvirtXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between a dozmod-server and a stateless client for VirtualBox configuration" ) + public void testConfigurationLogicDozModServerToStatelessClientVirtualBox() throws TransformationException + { + final String inputConfigFileName = "virtualbox_default-ubuntu_transform-privacy.vbox"; + final String expectedConfigFileName = "virtualbox_default-ubuntu_transform-non-persistent.vbox"; + final File inputConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVirtualBoxXmlFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( + ConfigurationLogicTestUtils.isVirtualBoxContentEqual( expectedTransformedConfig, transformedConfig ) ); + + // do not validate the VirtualBox configuration afterwards, since the inserted + // place holders do not match valid primitive values from the XML schema + //assertDoesNotThrow( () -> config.validate() ); + } + + @Test + @DisplayName( "Test transformation logic between dozmod-server and a stateless client for VMware configuration" ) + public void testConfigurationLogicDozModServerToStatelessClientVmware() throws TransformationException + { + final String inputConfigFileName = "vmware-player_default-ubuntu_transform-privacy.vmx"; + final String expectedConfigFileName = "vmware-player_default-ubuntu_transform-non-persistent.vmx"; + final File inputConfig = ConfigurationLogicTestResources.getVmwareVmxFile( inputConfigFileName ); + final File expectedConfig = ConfigurationLogicTestResources.getVmwareVmxFile( expectedConfigFileName ); + final VirtualizationConfiguration<?, ?, ?, ?> config; + config = ConfigurationLogicTestUtils.newVirtualizationConfigurationInstance( inputConfig ); + final ConfigurationLogicDozModServerToStatelessClient logic = new ConfigurationLogicDozModServerToStatelessClient(); + + logic.apply( config, ConfigurationLogicDozModServerToStatelessClientTest.DEFAULT_CONFIG_DATA ); + + final String transformedConfig = config.getConfigurationAsString(); + final String expectedTransformedConfig = ConfigurationLogicTestUtils.readFileToString( expectedConfig ); + + assertTrue( ConfigurationLogicTestUtils.isContentEqual( expectedTransformedConfig, transformedConfig ) ); + assertDoesNotThrow( () -> config.validate() ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java new file mode 100644 index 0000000..ceafceb --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestResources.java @@ -0,0 +1,32 @@ +package org.openslx.virtualization.configuration.logic; + +import java.io.File; +import java.net.URL; + +public class ConfigurationLogicTestResources +{ + private static final String VMWARE_PREFIX_PATH = File.separator + "vmware"; + private static final String VMWARE_PREFIX_PATH_VMX = VMWARE_PREFIX_PATH + File.separator + "vmx"; + + private static final String VIRTUALBOX_PREFIX_PATH = File.separator + "virtualbox"; + private static final String VIRTUALBOX_PREFIX_PATH_XML = VIRTUALBOX_PREFIX_PATH + File.separator + "xml"; + + private static File getFile( String prefixPath, String fileName ) + { + final String filePath = prefixPath + File.separator + fileName; + final URL fileUrl = ConfigurationLogicTestResources.class.getResource( filePath ); + return new File( fileUrl.getFile() ); + } + + public static File getVmwareVmxFile( String vmwareVmxFileName ) + { + return ConfigurationLogicTestResources.getFile( ConfigurationLogicTestResources.VMWARE_PREFIX_PATH_VMX, + vmwareVmxFileName ); + } + + public static File getVirtualBoxXmlFile( String virtualBoxXmlFileName ) + { + return ConfigurationLogicTestResources.getFile( ConfigurationLogicTestResources.VIRTUALBOX_PREFIX_PATH_XML, + virtualBoxXmlFileName ); + } +} diff --git a/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java new file mode 100644 index 0000000..07046b5 --- /dev/null +++ b/src/test/java/org/openslx/virtualization/configuration/logic/ConfigurationLogicTestUtils.java @@ -0,0 +1,100 @@ +package org.openslx.virtualization.configuration.logic; + +import static org.junit.jupiter.api.Assertions.fail; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.StringReader; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +import org.apache.commons.io.FileUtils; +import org.openslx.bwlp.thrift.iface.OperatingSystem; +import org.openslx.virtualization.configuration.VirtualizationConfiguration; + +public class ConfigurationLogicTestUtils +{ + // @formatter:off + public static final List<OperatingSystem> STUB_OS_LIST = Collections.unmodifiableList( Arrays.asList( + new OperatingSystem( 1, "Windows 7 (64 Bit)", null, "AMD64", 196608, 256 ), + new OperatingSystem( 2, "Windows 8 (32 Bit)", null, "x86", 4096, 32 ), + new OperatingSystem( 3, "Windows 8 (64 Bit)", null, "AMD64", 131072, 256 ), + new OperatingSystem( 4, "Ubuntu (32 Bit)", null, "x86", 0, 0 ), + new OperatingSystem( 5, "Ubuntu (64 Bit)", null, "AMD64", 0, 0 ), + new OperatingSystem( 6, "OpenSUSE (32 Bit)", null, "x86", 0, 0 ), + new OperatingSystem( 7, "OpenSUSE (64 Bit)", null, "AMD64", 0, 0 ), + new OperatingSystem( 8, "Other Linux (32 Bit)", null, "x86", 0, 0 ), + new OperatingSystem( 9, "Other Linux (64 Bit)", null, "AMD64", 0, 0 ), + new OperatingSystem( 10, "Windows 7 (32 Bit)", null, "x86", 4096, 32 ), + new OperatingSystem( 11, "Windows 2000 Professional", null, "x86", 4096, 4 ) ) ); + // @formatter:on + + private static final String REGEX_UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"; + + public static VirtualizationConfiguration<?, ?, ?, ?> newVirtualizationConfigurationInstance( File configFile ) + { + VirtualizationConfiguration<?, ?, ?, ?> config = null; + + try { + config = VirtualizationConfiguration.getInstance( ConfigurationLogicTestUtils.STUB_OS_LIST, configFile ); + } catch ( IOException e ) { + fail( "Virtualization configuration file '" + configFile.getName() + "' can not be processed!" ); + } + + if ( config == null ) { + fail( "Virtualization configuration can not be created from file '" + configFile.getName() + "'" ); + } + + return config; + } + + public static String readFileToString( File file ) + { + String content = null; + + try { + content = FileUtils.readFileToString( file, StandardCharsets.UTF_8 ); + } catch ( IOException e ) { + fail( "Could not read content of file '" + file.getName() + "'" ); + } + + return content; + } + + public static boolean isContentEqual( String content1, String content2 ) + { + final BufferedReader bfrContent1 = new BufferedReader( new StringReader( content1 ) ); + final BufferedReader bfrContent2 = new BufferedReader( new StringReader( content2 ) ); + final List<String> linesContent1 = bfrContent1.lines().collect( Collectors.toList() ); + final List<String> linesContent2 = bfrContent2.lines().collect( Collectors.toList() ); + + Collections.sort( linesContent1 ); + Collections.sort( linesContent2 ); + + return linesContent1.equals( linesContent2 ); + } + + public static String removeUuid( String content ) + { + final Pattern patternUuid = Pattern.compile( ConfigurationLogicTestUtils.REGEX_UUID ); + final Matcher matcherUuidContent = patternUuid.matcher( content ); + + // replace all UUIDs with the empty String + return matcherUuidContent.replaceAll( "" ); + } + + public static boolean isVirtualBoxContentEqual( String content1, String content2 ) + { + // replace all UUIDs with the empty String + final String filteredContent1 = ConfigurationLogicTestUtils.removeUuid( content1 ); + final String filteredContent2 = ConfigurationLogicTestUtils.removeUuid( content2 ); + + return ConfigurationLogicTestUtils.isContentEqual( filteredContent1, filteredContent2 ); + } +} diff --git a/src/test/java/org/openslx/vm/disk/DiskImageQcow2Test.java b/src/test/java/org/openslx/vm/disk/DiskImageQcow2Test.java index 530cd60..7804d7d 100644 --- a/src/test/java/org/openslx/vm/disk/DiskImageQcow2Test.java +++ b/src/test/java/org/openslx/vm/disk/DiskImageQcow2Test.java @@ -7,6 +7,7 @@ import java.io.IOException; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.openslx.virtualization.Version; import org.openslx.vm.disk.DiskImage.ImageFormat; public class DiskImageQcow2Test @@ -16,7 +17,7 @@ public class DiskImageQcow2Test public void testQcow2DiskImage() throws DiskImageException, IOException { final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -32,7 +33,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-on_l2-on.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -48,7 +49,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-on_l2-off.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -64,7 +65,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-off_l2-on.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -80,7 +81,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-16384_cp-off_l2-off.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -96,7 +97,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-on_l2-on.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -112,7 +113,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-on_l2-off.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -128,7 +129,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-off_l2-on.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -144,7 +145,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-65536_cp-off_l2-off.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -160,7 +161,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-on_l2-on.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -176,7 +177,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-on_l2-off.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -192,7 +193,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-off_l2-on.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -208,7 +209,7 @@ public class DiskImageQcow2Test { final DiskImage image = DiskImage .newInstance( DiskImageTestResources.getDiskFile( "image_cs-2097152_cp-off_l2-off.qcow2" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); + final Version imageVersion = new Version( Short.valueOf( "3" ) ); assertEquals( ImageFormat.QCOW2.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); diff --git a/src/test/java/org/openslx/vm/disk/DiskImageVdiTest.java b/src/test/java/org/openslx/vm/disk/DiskImageVdiTest.java index 492c6aa..85112cc 100644 --- a/src/test/java/org/openslx/vm/disk/DiskImageVdiTest.java +++ b/src/test/java/org/openslx/vm/disk/DiskImageVdiTest.java @@ -7,6 +7,7 @@ import java.io.IOException; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.openslx.virtualization.Version; import org.openslx.vm.disk.DiskImage.ImageFormat; public class DiskImageVdiTest @@ -16,7 +17,7 @@ public class DiskImageVdiTest public void testVdiDiskImage() throws DiskImageException, IOException { final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.vdi" ) ); - final int imageVersion = DiskImageUtils.versionFromMajorMinor( Short.valueOf( "1" ), Short.valueOf( "1" ) ); + final Version imageVersion = new Version( Short.valueOf( "1" ), Short.valueOf( "1" ) ); assertEquals( ImageFormat.VDI.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); @@ -25,13 +26,13 @@ public class DiskImageVdiTest 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 int imageVersion = DiskImageUtils.versionFromMajorMinor( Short.valueOf( "1" ), Short.valueOf( "1" ) ); + final Version imageVersion = new Version( Short.valueOf( "1" ), Short.valueOf( "1" ) ); assertEquals( ImageFormat.VDI.toString(), image.getFormat().toString() ); assertEquals( true, image.isStandalone() ); diff --git a/src/test/java/org/openslx/vm/disk/DiskImageVmdkTest.java b/src/test/java/org/openslx/vm/disk/DiskImageVmdkTest.java index 00cf561..4c8be82 100644 --- a/src/test/java/org/openslx/vm/disk/DiskImageVmdkTest.java +++ b/src/test/java/org/openslx/vm/disk/DiskImageVmdkTest.java @@ -8,6 +8,7 @@ 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.vm.disk.DiskImage.ImageFormat; public class DiskImageVmdkTest @@ -17,8 +18,8 @@ public class DiskImageVmdkTest public void testVmdkDiskImage() throws DiskImageException, IOException { final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image-default.vmdk" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "1" ) ); - final int imageHwVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "18" ) ); + 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() ); @@ -37,8 +38,8 @@ public class DiskImageVmdkTest public void testVmdkDiskImageType0() throws DiskImageException, IOException { final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t0.vmdk" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "1" ) ); - final int imageHwVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "18" ) ); + 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() ); @@ -93,8 +94,8 @@ public class DiskImageVmdkTest public void testVmdkDiskImageType5() throws DiskImageException, IOException { final DiskImage image = DiskImage.newInstance( DiskImageTestResources.getDiskFile( "image_t5.vmdk" ) ); - final int imageVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "3" ) ); - final int imageHwVersion = DiskImageUtils.versionFromMajor( Short.valueOf( "18" ) ); + 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() ); |