| // Licensed to the Apache Software Foundation (ASF) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The ASF licenses this file | |
| // to you under the Apache License, Version 2.0 (the | |
| // "License"); you may not use this file except in compliance | |
| // with the License. You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, | |
| // software distributed under the License is distributed on an | |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| // KIND, either express or implied. See the License for the | |
| // specific language governing permissions and limitations | |
| // under the License. | |
| package com.cloud.upgrade; | |
| import static com.cloud.upgrade.SystemVmTemplateRegistration.DEFAULT_SYSTEM_VM_GUEST_OS_NAME; | |
| import static org.junit.Assert.assertEquals; | |
| import static org.junit.Assert.assertFalse; | |
| import static org.junit.Assert.assertNotNull; | |
| import static org.junit.Assert.assertNull; | |
| import static org.junit.Assert.assertThrows; | |
| import static org.junit.Assert.assertTrue; | |
| import static org.junit.Assert.fail; | |
| import static org.mockito.ArgumentMatchers.any; | |
| import static org.mockito.ArgumentMatchers.anyInt; | |
| import static org.mockito.ArgumentMatchers.anyList; | |
| import static org.mockito.ArgumentMatchers.anyLong; | |
| import static org.mockito.ArgumentMatchers.anyString; | |
| import static org.mockito.ArgumentMatchers.eq; | |
| import static org.mockito.Mockito.doNothing; | |
| import static org.mockito.Mockito.doReturn; | |
| import static org.mockito.Mockito.doThrow; | |
| import static org.mockito.Mockito.mock; | |
| import static org.mockito.Mockito.never; | |
| import static org.mockito.Mockito.times; | |
| import static org.mockito.Mockito.verify; | |
| import static org.mockito.Mockito.when; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.nio.file.Files; | |
| import java.nio.file.Path; | |
| import java.nio.file.Paths; | |
| import java.util.ArrayList; | |
| import java.util.Date; | |
| import java.util.List; | |
| import java.util.Map; | |
| import org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine; | |
| import org.apache.cloudstack.framework.config.dao.ConfigurationDao; | |
| import org.apache.cloudstack.framework.config.impl.ConfigurationVO; | |
| import org.apache.cloudstack.storage.datastore.db.ImageStoreDao; | |
| import org.apache.cloudstack.storage.datastore.db.ImageStoreDetailsDao; | |
| import org.apache.cloudstack.storage.datastore.db.ImageStoreVO; | |
| import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao; | |
| import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO; | |
| import org.apache.cloudstack.utils.security.DigestHelper; | |
| import org.apache.commons.lang3.StringUtils; | |
| import org.junit.Before; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| import org.mockito.InjectMocks; | |
| import org.mockito.Mock; | |
| import org.mockito.MockedStatic; | |
| import org.mockito.Mockito; | |
| import org.mockito.Spy; | |
| import org.mockito.junit.MockitoJUnitRunner; | |
| import com.cloud.cpu.CPU; | |
| import com.cloud.dc.DataCenterVO; | |
| import com.cloud.dc.dao.ClusterDao; | |
| import com.cloud.dc.dao.DataCenterDao; | |
| import com.cloud.dc.dao.DataCenterDetailsDao; | |
| import com.cloud.hypervisor.Hypervisor; | |
| import com.cloud.storage.DataStoreRole; | |
| import com.cloud.storage.GuestOSVO; | |
| import com.cloud.storage.Storage; | |
| import com.cloud.storage.VMTemplateStorageResourceAssoc; | |
| import com.cloud.storage.VMTemplateVO; | |
| import com.cloud.storage.VMTemplateZoneVO; | |
| import com.cloud.storage.dao.GuestOSDao; | |
| import com.cloud.storage.dao.VMTemplateDao; | |
| import com.cloud.storage.dao.VMTemplateZoneDao; | |
| import com.cloud.template.VirtualMachineTemplate; | |
| import com.cloud.utils.HttpUtils; | |
| import com.cloud.utils.Pair; | |
| import com.cloud.utils.UriUtils; | |
| import com.cloud.utils.exception.CloudRuntimeException; | |
| import com.cloud.utils.script.Script; | |
| import com.cloud.vm.dao.VMInstanceDao; | |
| @RunWith(MockitoJUnitRunner.class) | |
| public class SystemVmTemplateRegistrationTest { | |
| @Mock | |
| ClusterDao clusterDao; | |
| @Mock | |
| VMTemplateDao vmTemplateDao; | |
| @Mock | |
| GuestOSDao guestOSDao; | |
| @Mock | |
| TemplateDataStoreDao templateDataStoreDao; | |
| @Mock | |
| ConfigurationDao configurationDao; | |
| @Mock | |
| DataCenterDao dataCenterDao; | |
| @Mock | |
| DataCenterDetailsDao dataCenterDetailsDao; | |
| @Mock | |
| VMTemplateZoneDao vmTemplateZoneDao; | |
| @Mock | |
| ImageStoreDao imageStoreDao; | |
| @Mock | |
| ImageStoreDetailsDao imageStoreDetailsDao; | |
| @Mock | |
| VMInstanceDao vmInstanceDao; | |
| @Spy | |
| @InjectMocks | |
| SystemVmTemplateRegistration systemVmTemplateRegistration = new SystemVmTemplateRegistration(); | |
| @Before | |
| public void setup() { | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.clear(); | |
| } | |
| private void setupMetadataFile(MockedStatic<SystemVmTemplateRegistration> mockedStatic, String content) { | |
| try { | |
| String location = "metadata.ini"; | |
| if (StringUtils.isNotBlank(content)) { | |
| File tempFile = File.createTempFile("metadata", ".ini"); | |
| location = tempFile.getAbsolutePath(); | |
| Files.write(Paths.get(location), content.getBytes()); | |
| tempFile.deleteOnExit(); | |
| } | |
| mockedStatic.when(SystemVmTemplateRegistration::getMetadataFilePath).thenReturn(location); | |
| } catch (Exception e) { | |
| fail(e.getMessage()); | |
| } | |
| } | |
| @Test | |
| public void test_parseMetadataFile_noFile() { | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class, Mockito.CALLS_REAL_METHODS)) { | |
| setupMetadataFile(mockedStatic, null); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, | |
| SystemVmTemplateRegistration::parseMetadataFile); | |
| assertTrue(exception.getMessage().contains("Failed to parse system VM Template metadata file")); | |
| } | |
| } | |
| @Test | |
| public void test_parseMetadataFile_invalidContent() { | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class, Mockito.CALLS_REAL_METHODS)) { | |
| setupMetadataFile(mockedStatic, "abc"); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, | |
| SystemVmTemplateRegistration::parseMetadataFile); | |
| assertTrue(exception.getMessage().contains("Failed to parse system VM Template metadata file")); | |
| } | |
| } | |
| @Test | |
| public void test_parseMetadataFile_success() { | |
| String metadataFileContent = "[default]\n" + | |
| "version = x.y.z.0\n" + | |
| "\n" + | |
| "[kvm-x86_64]\n" + | |
| "templatename = systemvm-kvm-x.y.z\n" + | |
| "checksum = abc1\n" + | |
| "downloadurl = https://download.cloudstack.org/systemvm/x.y/systemvmtemplate-x.y.z-kvm.qcow2.bz2\n" + | |
| "filename = systemvmtemplate-x.y.z-kvm.qcow2.bz2\n" + | |
| "\n" + | |
| "[kvm-aarch64]\n" + | |
| "templatename = systemvm-kvm-x.y.z\n" + | |
| "checksum = abc2\n" + | |
| "downloadurl = https://download.cloudstack.org/systemvm/x.y/systemvmtemplate-x.y.z-kvm.qcow2.bz2\n" + | |
| "filename = systemvmtemplate-x.y.z-kvm.qcow2.bz2\n" + | |
| "\n" + | |
| "[vmware]\n" + | |
| "templatename = systemvm-vmware-x.y.z\n" + | |
| "checksum = abc3\n" + | |
| "downloadurl = https://download.cloudstack.org/systemvm/x.y/systemvmtemplate-x.y.z-vmware.ova\n" + | |
| "filename = systemvmtemplate-x.y.z-vmware.ova\n"; | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class, Mockito.CALLS_REAL_METHODS)) { | |
| setupMetadataFile(mockedStatic, metadataFileContent); | |
| String version = SystemVmTemplateRegistration.parseMetadataFile(); | |
| assertEquals("x.y.z.0", version); | |
| } | |
| assertNull(SystemVmTemplateRegistration.getMetadataTemplateDetails(Hypervisor.HypervisorType.XenServer, | |
| CPU.CPUArch.getDefault())); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| SystemVmTemplateRegistration.getMetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| CPU.CPUArch.amd64); | |
| assertNotNull(templateDetails); | |
| assertEquals(CPU.CPUArch.amd64, templateDetails.getArch()); | |
| assertEquals(Hypervisor.HypervisorType.KVM, templateDetails.getHypervisorType()); | |
| templateDetails = | |
| SystemVmTemplateRegistration.getMetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| CPU.CPUArch.arm64); | |
| assertNotNull(templateDetails); | |
| assertEquals(CPU.CPUArch.arm64, templateDetails.getArch()); | |
| assertEquals(Hypervisor.HypervisorType.KVM, templateDetails.getHypervisorType()); | |
| templateDetails = | |
| SystemVmTemplateRegistration.getMetadataTemplateDetails(Hypervisor.HypervisorType.VMware, | |
| CPU.CPUArch.getDefault()); | |
| assertNotNull(templateDetails); | |
| assertEquals(CPU.CPUArch.getDefault(), templateDetails.getArch()); | |
| assertEquals(Hypervisor.HypervisorType.VMware, templateDetails.getHypervisorType()); | |
| } | |
| @Test | |
| public void testMountStore_nullStoreUrl() throws Exception { | |
| try (MockedStatic<Script> scriptMock = Mockito.mockStatic(Script.class)) { | |
| SystemVmTemplateRegistration.mountStore(null, "/mnt/nfs", "nfs3"); | |
| scriptMock.verifyNoInteractions(); | |
| } | |
| } | |
| @Test | |
| public void testMountStore_validStoreUrl() throws Exception { | |
| String storeUrl = "nfs://192.168.1.100/export"; | |
| String path = "/mnt/nfs"; | |
| String nfsVersion = "nfs3"; | |
| String expectedMountCommand = "expectedMountCommand"; | |
| try (MockedStatic<UriUtils> uriUtilsMock = Mockito.mockStatic(UriUtils.class); | |
| MockedStatic<SystemVmTemplateRegistration> sysVmMock = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class, Mockito.CALLS_REAL_METHODS); | |
| MockedStatic<Script> scriptMock = Mockito.mockStatic(Script.class)) { | |
| uriUtilsMock.when(() -> UriUtils.encodeURIComponent(storeUrl)).thenReturn(storeUrl); | |
| sysVmMock.when(() -> SystemVmTemplateRegistration.getMountCommand( | |
| eq(nfsVersion), | |
| eq("192.168.1.100:/export"), | |
| eq(path) | |
| )).thenReturn(expectedMountCommand); | |
| SystemVmTemplateRegistration.mountStore(storeUrl, path, nfsVersion); | |
| scriptMock.verify(() -> Script.runSimpleBashScript(expectedMountCommand), times(1)); | |
| } | |
| } | |
| @Test | |
| public void testValidateTemplateFile_fileNotFound() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| new SystemVmTemplateRegistration.MetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| "name", "file", "url", "checksum", CPU.CPUArch.amd64, "guestos"); | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.add(details); | |
| doReturn(null).when(systemVmTemplateRegistration).getTemplateFile(details); | |
| try { | |
| systemVmTemplateRegistration.getValidatedTemplateDetailsForHypervisorAndArch(details.getHypervisorType(), | |
| details.getArch()); | |
| fail("Expected CloudRuntimeException due to missing template file"); | |
| } catch (CloudRuntimeException e) { | |
| assertEquals("Failed to find local template file", e.getMessage()); | |
| } | |
| } | |
| @Test | |
| public void testValidateTemplateFile_checksumMismatch() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| new SystemVmTemplateRegistration.MetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| "name", "file", "url", "checksum", CPU.CPUArch.amd64, "guestos"); | |
| File dummyFile = new File("dummy.txt"); | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.add(details); | |
| doReturn(dummyFile).when(systemVmTemplateRegistration).getTemplateFile(details); | |
| try (MockedStatic<DigestHelper> digestMock = Mockito.mockStatic(DigestHelper.class)) { | |
| digestMock.when(() -> DigestHelper.calculateChecksum(dummyFile)).thenReturn("differentChecksum"); | |
| systemVmTemplateRegistration.getValidatedTemplateDetailsForHypervisorAndArch(details.getHypervisorType(), | |
| details.getArch()); | |
| fail("Expected CloudRuntimeException due to checksum failure"); | |
| } catch (CloudRuntimeException e) { | |
| assertEquals("Checksum failed for local template file", e.getMessage()); | |
| } | |
| } | |
| @Test | |
| public void testValidateTemplateFile_success() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| new SystemVmTemplateRegistration.MetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| "name", "file", "url", "checksum", CPU.CPUArch.amd64, "guestos"); | |
| File dummyFile = new File("dummy.txt"); | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.add(details); | |
| doReturn(dummyFile).when(systemVmTemplateRegistration).getTemplateFile(details); | |
| try (MockedStatic<DigestHelper> digestMock = Mockito.mockStatic(DigestHelper.class)) { | |
| digestMock.when(() -> DigestHelper.calculateChecksum(dummyFile)).thenReturn("checksum"); | |
| systemVmTemplateRegistration.getValidatedTemplateDetailsForHypervisorAndArch(details.getHypervisorType(), | |
| details.getArch()); | |
| } | |
| } | |
| @Test | |
| public void testValidateAndAddExistingTemplateToStore() { | |
| long zoneId = 1L; | |
| Hypervisor.HypervisorType hypervisor = Hypervisor.HypervisorType.KVM; | |
| VMTemplateVO templateVO = new VMTemplateVO(); | |
| templateVO.setHypervisorType(hypervisor); | |
| templateVO.setArch(CPU.CPUArch.getDefault()); | |
| TemplateDataStoreVO templateDataStoreVO = new TemplateDataStoreVO(); | |
| Long storeId = 123L; | |
| String filePath = "/dummy/path"; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| doReturn(details).when(systemVmTemplateRegistration) | |
| .getValidatedTemplateDetailsForHypervisorAndArch(hypervisor, templateVO.getArch()); | |
| doNothing().when(systemVmTemplateRegistration).addExistingTemplateToStore(templateVO, details, | |
| templateDataStoreVO, zoneId, storeId, filePath); | |
| systemVmTemplateRegistration.validateAndAddTemplateToStore(templateVO, templateDataStoreVO, zoneId, storeId, | |
| filePath); | |
| verify(systemVmTemplateRegistration) | |
| .getValidatedTemplateDetailsForHypervisorAndArch(hypervisor, templateVO.getArch()); | |
| verify(systemVmTemplateRegistration).addExistingTemplateToStore(templateVO, details, templateDataStoreVO, | |
| zoneId, storeId, filePath); | |
| } | |
| @Test | |
| public void testValidateAndAddExistingTemplateToStoreForNonExistingEntries() { | |
| long zoneId = 1L; | |
| Hypervisor.HypervisorType hypervisor = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.amd64; | |
| String name = "TestTemplateNonExisting"; | |
| long storeId = 123L; | |
| String filePath = "/dummy/path/nonexisting"; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| doReturn(details).when(systemVmTemplateRegistration) | |
| .getValidatedTemplateDetailsForHypervisorAndArch(hypervisor, arch); | |
| doNothing().when(systemVmTemplateRegistration).registerNewTemplate(name, details, zoneId, storeId, filePath); | |
| systemVmTemplateRegistration.validateAndRegisterNewTemplate(hypervisor, arch, name, zoneId, storeId, filePath); | |
| verify(systemVmTemplateRegistration).getValidatedTemplateDetailsForHypervisorAndArch(hypervisor, arch); | |
| verify(systemVmTemplateRegistration).registerNewTemplate(name, details, zoneId, storeId, filePath); | |
| } | |
| @Test | |
| public void testGetTemplateFile_fileExists() throws Exception { | |
| File tempFile = File.createTempFile("template", ".qcow2"); | |
| tempFile.deleteOnExit(); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(details.getDefaultFilePath()).thenReturn(tempFile.getAbsolutePath()); | |
| File result = systemVmTemplateRegistration.getTemplateFile(details); | |
| assertNotNull(result); | |
| assertEquals(tempFile.getAbsolutePath(), result.getAbsolutePath()); | |
| } | |
| @Test | |
| public void testGetTemplateFile_fileDoesNotExist_downloadFails() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| new SystemVmTemplateRegistration.MetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| "name", "nonexistent.qcow2", "http://example.com/file.qcow2", | |
| "", CPU.CPUArch.arm64, "guestos"); | |
| try (MockedStatic<Files> filesMock = Mockito.mockStatic(Files.class); | |
| MockedStatic<HttpUtils> httpMock = Mockito.mockStatic(HttpUtils.class)) { | |
| filesMock.when(() -> Files.isWritable(any(Path.class))).thenReturn(true); | |
| httpMock.when(() -> HttpUtils.downloadFileWithProgress(eq(details.getUrl()), anyString(), any())) | |
| .thenReturn(false); | |
| File result = systemVmTemplateRegistration.getTemplateFile(details); | |
| assertNull(result); | |
| } | |
| } | |
| @Test | |
| public void testGetTemplateFile_fileDoesNotExist_downloadSucceeds() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| new SystemVmTemplateRegistration.MetadataTemplateDetails(Hypervisor.HypervisorType.KVM, | |
| "name", "file.qcow2", "http://example.com/file.qcow2", | |
| "", CPU.CPUArch.arm64, "guestos"); | |
| try (MockedStatic<Files> filesMock = Mockito.mockStatic(Files.class); | |
| MockedStatic<HttpUtils> httpMock = Mockito.mockStatic(HttpUtils.class)) { | |
| filesMock.when(() -> Files.isWritable(any(Path.class))).thenReturn(false); | |
| File expectedFile = new File(systemVmTemplateRegistration.getTempDownloadDir(), details.getFilename()); | |
| httpMock.when(() -> HttpUtils.downloadFileWithProgress(eq(details.getUrl()), eq(expectedFile.getAbsolutePath()), any())) | |
| .thenReturn(true); | |
| File result = systemVmTemplateRegistration.getTemplateFile(details); | |
| assertNotNull(result); | |
| assertEquals(expectedFile.getAbsolutePath(), result.getAbsolutePath()); | |
| assertEquals(expectedFile.getAbsolutePath(), details.getDownloadedFilePath()); | |
| } | |
| } | |
| @Test | |
| public void testValidateTemplates_metadataTemplateSkip() { | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.VMware; | |
| CPU.CPUArch arch = CPU.CPUArch.arm64; | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> list = new ArrayList<>(); | |
| list.add(new Pair<>(hypervisorType, arch)); | |
| systemVmTemplateRegistration.validateTemplates(list); | |
| verify(systemVmTemplateRegistration, never()).getValidatedTemplateDetailsForHypervisorAndArch(hypervisorType, | |
| arch); | |
| } | |
| @Test(expected = CloudRuntimeException.class) | |
| public void testValidateTemplates_fileFailure() { | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.amd64; | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> list = new ArrayList<>(); | |
| list.add(new Pair<>(hypervisorType, arch)); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(details.getHypervisorType()).thenReturn(hypervisorType); | |
| when(details.getArch()).thenReturn(arch); | |
| File mockFile = Mockito.mock(File.class); | |
| when(details.isFileChecksumDifferent(mockFile)).thenReturn(true); | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.add(details); | |
| doReturn(mockFile).when(systemVmTemplateRegistration).getTemplateFile(details); | |
| systemVmTemplateRegistration.validateTemplates(list); | |
| } | |
| @Test(expected = CloudRuntimeException.class) | |
| public void testValidateTemplates_downloadableFileNotFound() { | |
| CPU.CPUArch arch = SystemVmTemplateRegistration.DOWNLOADABLE_TEMPLATE_ARCH_TYPES.get(0); | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> list = new ArrayList<>(); | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| list.add(new Pair<>(hypervisorType, arch)); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(details.getHypervisorType()).thenReturn(hypervisorType); | |
| when(details.getArch()).thenReturn(arch); | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.add(details); | |
| doReturn(null).when(systemVmTemplateRegistration).getTemplateFile(details); | |
| systemVmTemplateRegistration.validateTemplates(list); | |
| } | |
| @Test | |
| public void testValidateTemplates_success() { | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.amd64; | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> list = new ArrayList<>(); | |
| list.add(new Pair<>(hypervisorType, arch)); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(details.getHypervisorType()).thenReturn(hypervisorType); | |
| when(details.getArch()).thenReturn(arch); | |
| File mockFile = Mockito.mock(File.class); | |
| when(details.isFileChecksumDifferent(mockFile)).thenReturn(false); | |
| SystemVmTemplateRegistration.METADATA_TEMPLATE_LIST.add(details); | |
| doReturn(mockFile).when(systemVmTemplateRegistration).getTemplateFile(details); | |
| systemVmTemplateRegistration.validateTemplates(list); | |
| } | |
| @Test | |
| public void testAddExistingTemplatesForZoneToStore() { | |
| long zoneId = 1L; | |
| String filePath = "dummyFilePath"; | |
| String nfsVersion = "nfs3"; | |
| Pair<String, Long> storeUrlAndId = new Pair<>("nfs://dummy", 100L); | |
| String name = "existing"; | |
| String url = "url"; | |
| doReturn(storeUrlAndId).when(systemVmTemplateRegistration).getNfsStoreInZone(zoneId); | |
| doReturn(nfsVersion).when(systemVmTemplateRegistration).getNfsVersion(storeUrlAndId.second()); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = Mockito.mockStatic( | |
| SystemVmTemplateRegistration.class)) { | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> hypervisorArchList = new ArrayList<>(); | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.getDefault(); | |
| hypervisorArchList.add(new Pair<>(hypervisorType, arch)); | |
| doReturn(hypervisorArchList).when(clusterDao).listDistinctHypervisorsAndArchExcludingExternalType(zoneId); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(details.getArch()).thenReturn(CPU.CPUArch.getDefault()); | |
| when(details.getName()).thenReturn(name); | |
| when(details.getUrl()).thenReturn(url); | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.getMetadataTemplateDetails(Mockito.any(), | |
| Mockito.any())).thenReturn(details); | |
| doNothing().when(systemVmTemplateRegistration).registerNewTemplate(name, details, zoneId, | |
| storeUrlAndId.second(), filePath); | |
| systemVmTemplateRegistration.registerTemplatesForZone(zoneId, filePath); | |
| mockedStatic.verify(() -> SystemVmTemplateRegistration.mountStore(storeUrlAndId.first(), filePath, | |
| nfsVersion)); | |
| verify(systemVmTemplateRegistration).registerNewTemplate(name, details, zoneId, | |
| storeUrlAndId.second(), filePath); | |
| } | |
| } | |
| @Test | |
| public void updateOrRegisterSystemVmTemplate_UpdatesRegisteredTemplate() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getName()).thenReturn("templateName"); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| VMTemplateVO registeredTemplate = Mockito.mock(VMTemplateVO.class); | |
| when(registeredTemplate.getId()).thenReturn(1L); | |
| doReturn(registeredTemplate).when(systemVmTemplateRegistration).getRegisteredTemplate( | |
| "templateName", Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64, "http://example.com/template"); | |
| doNothing().when(systemVmTemplateRegistration).updateRegisteredTemplateDetails(1L, templateDetails, | |
| null); | |
| boolean result = systemVmTemplateRegistration.updateOrRegisterSystemVmTemplate(templateDetails, | |
| new ArrayList<>()); | |
| assertFalse(result); | |
| verify(systemVmTemplateRegistration).updateRegisteredTemplateDetails(1L, templateDetails, null); | |
| } | |
| @Test | |
| public void updateOrRegisterSystemVmTemplate_SkipsUnusedHypervisorArch() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getName()).thenReturn("templateName"); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| doReturn(null).when(systemVmTemplateRegistration).getRegisteredTemplate( | |
| "templateName", Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64, "http://example.com/template"); | |
| doReturn(null).when(vmTemplateDao).findLatestTemplateByTypeAndHypervisorAndArch( | |
| Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64, Storage.TemplateType.SYSTEM); | |
| boolean result = systemVmTemplateRegistration.updateOrRegisterSystemVmTemplate(templateDetails, new ArrayList<>()); | |
| assertFalse(result); | |
| verify(systemVmTemplateRegistration, never()).registerTemplates(anyList()); | |
| } | |
| @Test | |
| public void updateOrRegisterSystemVmTemplate_RegistersNewTemplate() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getName()).thenReturn("templateName"); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| doReturn(null).when(systemVmTemplateRegistration).getRegisteredTemplate( | |
| "templateName", Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64, "http://example.com/template"); | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> hypervisorsInUse = new ArrayList<>(); | |
| hypervisorsInUse.add(new Pair<>(Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64)); | |
| doNothing().when(systemVmTemplateRegistration).registerTemplates(hypervisorsInUse); | |
| boolean result = systemVmTemplateRegistration.updateOrRegisterSystemVmTemplate(templateDetails, hypervisorsInUse); | |
| assertTrue(result); | |
| verify(systemVmTemplateRegistration).registerTemplates(eq(hypervisorsInUse)); | |
| } | |
| @Test | |
| public void updateOrRegisterSystemVmTemplate_ThrowsExceptionOnRegistrationFailure() { | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getName()).thenReturn("templateName"); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| doReturn(null).when(systemVmTemplateRegistration).getRegisteredTemplate( | |
| "templateName", Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64, "http://example.com/template"); | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> hypervisorsInUse = new ArrayList<>(); | |
| hypervisorsInUse.add(new Pair<>(Hypervisor.HypervisorType.KVM, CPU.CPUArch.amd64)); | |
| doThrow(new CloudRuntimeException("Registration failed")).when(systemVmTemplateRegistration).registerTemplates(hypervisorsInUse); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, | |
| () -> systemVmTemplateRegistration.updateOrRegisterSystemVmTemplate(templateDetails, hypervisorsInUse)); | |
| assertTrue(exception.getMessage().contains("Failed to register")); | |
| } | |
| @Test | |
| public void updateRegisteredTemplateDetails_UpdatesTemplateSuccessfully() { | |
| Long templateId = 1L; | |
| Long zoneId = 2L; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| String templateName = "templateName"; | |
| when(templateVO.getName()).thenReturn(templateName); | |
| GuestOSVO guestOS = Mockito.mock(GuestOSVO.class); | |
| when(templateDetails.getGuestOs()).thenReturn("Debian"); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(vmTemplateDao.findById(templateId)).thenReturn(templateVO); | |
| when(guestOSDao.findOneByDisplayName("Debian")).thenReturn(guestOS); | |
| when(guestOS.getId()).thenReturn(10L); | |
| when(vmTemplateDao.update(templateVO.getId(), templateVO)).thenReturn(true); | |
| doNothing().when(systemVmTemplateRegistration).updateSystemVMEntries(templateId, Hypervisor.HypervisorType.KVM); | |
| doNothing().when(systemVmTemplateRegistration).updateConfigurationParams(Hypervisor.HypervisorType.KVM, | |
| templateName, zoneId); | |
| systemVmTemplateRegistration.updateRegisteredTemplateDetails(templateId, templateDetails, zoneId); | |
| verify(templateVO).setTemplateType(Storage.TemplateType.SYSTEM); | |
| verify(templateVO).setGuestOSId(10); | |
| verify(vmTemplateDao).update(templateVO.getId(), templateVO); | |
| verify(systemVmTemplateRegistration).updateSystemVMEntries(templateId, Hypervisor.HypervisorType.KVM); | |
| verify(systemVmTemplateRegistration).updateConfigurationParams(Hypervisor.HypervisorType.KVM, | |
| templateName, zoneId); | |
| } | |
| @Test | |
| public void updateRegisteredTemplateDetails_ThrowsExceptionWhenUpdateFails() { | |
| Long templateId = 1L; | |
| Long zoneId = 2L; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| when(templateDetails.getGuestOs()).thenReturn("Debian"); | |
| when(vmTemplateDao.findById(templateId)).thenReturn(templateVO); | |
| when(vmTemplateDao.update(templateVO.getId(), templateVO)).thenReturn(false); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, | |
| () -> systemVmTemplateRegistration.updateRegisteredTemplateDetails(templateId, templateDetails, zoneId)); | |
| assertTrue(exception.getMessage().contains("Exception while updating template with id")); | |
| verify(systemVmTemplateRegistration, never()).updateSystemVMEntries(anyLong(), any()); | |
| verify(systemVmTemplateRegistration, never()).updateConfigurationParams(any(), any(), any()); | |
| } | |
| @Test | |
| public void updateRegisteredTemplateDetails_SkipsGuestOSUpdateWhenNotFound() { | |
| Long templateId = 1L; | |
| Long zoneId = 2L; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| String templateName = "templateName"; | |
| when(templateVO.getName()).thenReturn(templateName); | |
| when(templateDetails.getGuestOs()).thenReturn("NonExistentOS"); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(vmTemplateDao.findById(templateId)).thenReturn(templateVO); | |
| when(guestOSDao.findOneByDisplayName("NonExistentOS")).thenReturn(null); | |
| when(vmTemplateDao.update(templateVO.getId(), templateVO)).thenReturn(true); | |
| doNothing().when(systemVmTemplateRegistration).updateSystemVMEntries(templateId, Hypervisor.HypervisorType.KVM); | |
| doNothing().when(systemVmTemplateRegistration).updateConfigurationParams(Hypervisor.HypervisorType.KVM, | |
| templateName, zoneId); | |
| systemVmTemplateRegistration.updateRegisteredTemplateDetails(templateId, templateDetails, zoneId); | |
| verify(templateVO, never()).setGuestOSId(anyInt()); | |
| verify(vmTemplateDao).update(templateVO.getId(), templateVO); | |
| verify(systemVmTemplateRegistration).updateSystemVMEntries(templateId, Hypervisor.HypervisorType.KVM); | |
| verify(systemVmTemplateRegistration).updateConfigurationParams(Hypervisor.HypervisorType.KVM, | |
| templateName, zoneId); | |
| } | |
| @Test | |
| public void registerTemplatesForZone_SuccessfullyRegistersNewTemplate() { | |
| long zoneId = 1L; | |
| String storeMountPath = "/mnt/nfs"; | |
| Pair<String, Long> storeUrlAndId = new Pair<>("nfs://dummy", 100L); | |
| String nfsVersion = "nfs3"; | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> hypervisorArchList = new ArrayList<>(); | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.amd64; | |
| hypervisorArchList.add(new Pair<>(hypervisorType, arch)); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getHypervisorType()).thenReturn(hypervisorType); | |
| when(templateDetails.getArch()).thenReturn(arch); | |
| String name = "TestTemplate"; | |
| String url = "http://example.com/template"; | |
| when(templateDetails.getName()).thenReturn(name); | |
| when(templateDetails.getUrl()).thenReturn(url); | |
| doReturn(storeUrlAndId).when(systemVmTemplateRegistration).getNfsStoreInZone(zoneId); | |
| doReturn(nfsVersion).when(systemVmTemplateRegistration).getNfsVersion(storeUrlAndId.second()); | |
| doReturn(null).when(systemVmTemplateRegistration).getRegisteredTemplate( | |
| name, hypervisorType, arch, url); | |
| doNothing().when(systemVmTemplateRegistration).registerNewTemplate( | |
| name, templateDetails, zoneId, storeUrlAndId.second(), storeMountPath); | |
| doReturn(hypervisorArchList).when(clusterDao).listDistinctHypervisorsAndArchExcludingExternalType(zoneId); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.getMetadataTemplateDetails( | |
| hypervisorType, arch)).thenReturn(templateDetails); | |
| systemVmTemplateRegistration.registerTemplatesForZone(zoneId, storeMountPath); | |
| mockedStatic.verify(() -> SystemVmTemplateRegistration.mountStore( | |
| eq(storeUrlAndId.first()), eq(storeMountPath), eq(nfsVersion)), times(1)); | |
| verify(systemVmTemplateRegistration).registerNewTemplate( | |
| templateDetails.getName(), templateDetails, zoneId, storeUrlAndId.second(), storeMountPath); | |
| } | |
| } | |
| @Test | |
| public void registerTemplatesForZone_SkipsWhenTemplateDetailsNotFound() { | |
| long zoneId = 1L; | |
| String storeMountPath = "/mnt/nfs"; | |
| Pair<String, Long> storeUrlAndId = new Pair<>("nfs://dummy", 100L); | |
| String nfsVersion = "nfs3"; | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> hypervisorArchList = new ArrayList<>(); | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.amd64; | |
| hypervisorArchList.add(new Pair<>(hypervisorType, arch)); | |
| doReturn(storeUrlAndId).when(systemVmTemplateRegistration).getNfsStoreInZone(zoneId); | |
| doReturn(nfsVersion).when(systemVmTemplateRegistration).getNfsVersion(storeUrlAndId.second()); | |
| doReturn(hypervisorArchList).when(clusterDao).listDistinctHypervisorsAndArchExcludingExternalType(zoneId); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.getMetadataTemplateDetails( | |
| hypervisorType, arch)).thenReturn(null); | |
| systemVmTemplateRegistration.registerTemplatesForZone(zoneId, storeMountPath); | |
| mockedStatic.verify(() -> SystemVmTemplateRegistration.mountStore( | |
| eq(storeUrlAndId.first()), eq(storeMountPath), eq(nfsVersion)), times(1)); | |
| verify(systemVmTemplateRegistration, never()).registerNewTemplate(any(), any(), anyLong(), anyLong(), any()); | |
| } | |
| } | |
| @Test | |
| public void registerTemplatesForZone_AddsExistingTemplateToStore() { | |
| long zoneId = 1L; | |
| String storeMountPath = "/mnt/nfs"; | |
| Pair<String, Long> storeUrlAndId = new Pair<>("nfs://dummy", 100L); | |
| String nfsVersion = "nfs3"; | |
| List<Pair<Hypervisor.HypervisorType, CPU.CPUArch>> hypervisorArchList = new ArrayList<>(); | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| CPU.CPUArch arch = CPU.CPUArch.amd64; | |
| hypervisorArchList.add(new Pair<>(hypervisorType, arch)); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getHypervisorType()).thenReturn(hypervisorType); | |
| when(templateDetails.getArch()).thenReturn(arch); | |
| String name = "TestTemplate"; | |
| String url = "http://example.com/template"; | |
| when(templateDetails.getName()).thenReturn(name); | |
| when(templateDetails.getUrl()).thenReturn(url); | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| long templateId = 100L; | |
| when(templateVO.getId()).thenReturn(templateId); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| String installPath = "/template/install/path"; | |
| when(templateDataStoreVO.getInstallPath()).thenReturn(installPath); | |
| doReturn(storeUrlAndId).when(systemVmTemplateRegistration).getNfsStoreInZone(zoneId); | |
| doReturn(nfsVersion).when(systemVmTemplateRegistration).getNfsVersion(storeUrlAndId.second()); | |
| doReturn(hypervisorArchList).when(clusterDao).listDistinctHypervisorsAndArchExcludingExternalType(zoneId); | |
| doReturn(templateVO).when(systemVmTemplateRegistration).getRegisteredTemplate(name, hypervisorType, arch, url); | |
| doReturn(templateDataStoreVO).when(templateDataStoreDao) | |
| .findByStoreTemplate(storeUrlAndId.second(), templateId); | |
| doReturn(false).when(systemVmTemplateRegistration).validateIfSeeded( | |
| templateDataStoreVO, storeUrlAndId.first(), installPath, nfsVersion); | |
| doNothing().when(systemVmTemplateRegistration).addExistingTemplateToStore( | |
| templateVO, templateDetails, templateDataStoreVO, zoneId, storeUrlAndId.second(), storeMountPath); | |
| doNothing().when(systemVmTemplateRegistration).updateRegisteredTemplateDetails( | |
| templateId, templateDetails, zoneId); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.getMetadataTemplateDetails( | |
| hypervisorType, arch)).thenReturn(templateDetails); | |
| systemVmTemplateRegistration.registerTemplatesForZone(zoneId, storeMountPath); | |
| verify(systemVmTemplateRegistration).addExistingTemplateToStore( | |
| templateVO, templateDetails, templateDataStoreVO, zoneId, storeUrlAndId.second(), storeMountPath); | |
| verify(systemVmTemplateRegistration).updateRegisteredTemplateDetails(templateId, templateDetails, zoneId); | |
| } | |
| } | |
| @Test | |
| public void performTemplateRegistrationOperations_CreatesNewTemplateWhenNotExists() { | |
| String name = "TestTemplate"; | |
| String url = "http://example.com/template"; | |
| String checksum = "abc123"; | |
| Storage.ImageFormat format = Storage.ImageFormat.QCOW2; | |
| long guestOsId = 1L; | |
| Long storeId = 100L; | |
| Long templateId = null; | |
| String filePath = "/mnt/nfs"; | |
| TemplateDataStoreVO templateDataStoreVO = null; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| doReturn(new VMTemplateVO()).when(vmTemplateDao).persist(any()); | |
| doNothing().when(systemVmTemplateRegistration).createCrossZonesTemplateZoneRefEntries(anyLong()); | |
| doNothing().when(systemVmTemplateRegistration).createTemplateStoreRefEntry(any()); | |
| doNothing().when(systemVmTemplateRegistration).setupTemplateOnStore(anyString(), any(), anyString()); | |
| doNothing().when(systemVmTemplateRegistration).readTemplateProperties(anyString(), any()); | |
| doNothing().when(systemVmTemplateRegistration).updateTemplateDetails(any()); | |
| Long result = systemVmTemplateRegistration.performTemplateRegistrationOperations(name, templateDetails, url, checksum, format, guestOsId, storeId, templateId, filePath, templateDataStoreVO); | |
| assertNotNull(result); | |
| verify(vmTemplateDao).persist(any()); | |
| verify(systemVmTemplateRegistration).createCrossZonesTemplateZoneRefEntries(anyLong()); | |
| verify(systemVmTemplateRegistration).createTemplateStoreRefEntry(any()); | |
| verify(systemVmTemplateRegistration).setupTemplateOnStore(anyString(), any(), anyString()); | |
| verify(systemVmTemplateRegistration).updateTemplateDetails(any()); | |
| } | |
| @Test | |
| public void performTemplateRegistrationOperations_UpdatesExistingTemplate() { | |
| String name = "TestTemplate"; | |
| String url = "http://example.com/template"; | |
| String checksum = "abc123"; | |
| Storage.ImageFormat format = Storage.ImageFormat.QCOW2; | |
| long guestOsId = 1L; | |
| Long storeId = 100L; | |
| Long templateId = 1L; | |
| String filePath = "/mnt/nfs"; | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| doNothing().when(systemVmTemplateRegistration).createCrossZonesTemplateZoneRefEntries(anyLong()); | |
| doNothing().when(systemVmTemplateRegistration).setupTemplateOnStore(anyString(), any(), anyString()); | |
| doNothing().when(systemVmTemplateRegistration).readTemplateProperties(anyString(), any()); | |
| doNothing().when(systemVmTemplateRegistration).updateTemplateDetails(any()); | |
| Long result = systemVmTemplateRegistration.performTemplateRegistrationOperations(name, templateDetails, url, checksum, format, guestOsId, storeId, templateId, filePath, templateDataStoreVO); | |
| assertNotNull(result); | |
| assertEquals(templateId, result); | |
| verify(vmTemplateDao, never()).persist(any()); | |
| verify(systemVmTemplateRegistration).createCrossZonesTemplateZoneRefEntries(anyLong()); | |
| verify(systemVmTemplateRegistration, never()).createTemplateStoreRefEntry(any()); | |
| verify(systemVmTemplateRegistration).setupTemplateOnStore(anyString(), any(), anyString()); | |
| verify(systemVmTemplateRegistration).updateTemplateDetails(any()); | |
| } | |
| @Test | |
| public void performTemplateRegistrationOperations_ThrowsExceptionWhenTemplateCreationFails() { | |
| String name = "TestTemplate"; | |
| String url = "http://example.com/template"; | |
| String checksum = "abc123"; | |
| Storage.ImageFormat format = Storage.ImageFormat.QCOW2; | |
| long guestOsId = 1L; | |
| Long storeId = 100L; | |
| Long templateId = null; | |
| String filePath = "/mnt/nfs"; | |
| TemplateDataStoreVO templateDataStoreVO = null; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM); | |
| when(templateDetails.getArch()).thenReturn(CPU.CPUArch.amd64); | |
| doReturn(null).when(vmTemplateDao).persist(any()); | |
| assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.performTemplateRegistrationOperations(name, templateDetails, url, checksum, format, guestOsId, storeId, templateId, filePath, templateDataStoreVO); | |
| }); | |
| verify(vmTemplateDao).persist(any()); | |
| verify(systemVmTemplateRegistration, never()).createCrossZonesTemplateZoneRefEntries(anyLong()); | |
| verify(systemVmTemplateRegistration, never()).createTemplateStoreRefEntry(any()); | |
| verify(systemVmTemplateRegistration, never()).setupTemplateOnStore(anyString(), any(), anyString()); | |
| verify(systemVmTemplateRegistration, never()).updateTemplateDetails(any()); | |
| } | |
| @Test | |
| public void setupTemplateOnStore_ThrowsExceptionWhenScriptNotFound() { | |
| String templateName = "templateName"; | |
| String destTempFolder = "/tmp/folder"; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| try (MockedStatic<Script> scriptMock = Mockito.mockStatic(Script.class)) { | |
| scriptMock.when(() -> Script.findScript(SystemVmTemplateRegistration.STORAGE_SCRIPTS_DIR, | |
| "setup-sysvm-tmplt")).thenReturn(null); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.setupTemplateOnStore(templateName, templateDetails, destTempFolder); | |
| }); | |
| assertTrue(exception.getMessage().contains("Unable to find the setup-sysvm-tmplt script")); | |
| } | |
| } | |
| @Test | |
| public void updateTemplateEntriesOnFailure_RemovesTemplateAndDataStoreEntry() { | |
| long templateId = 1L; | |
| VMTemplateVO template = Mockito.mock(VMTemplateVO.class); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| when(vmTemplateDao.createForUpdate(templateId)).thenReturn(template); | |
| when(template.getId()).thenReturn(templateId); | |
| when(templateDataStoreDao.findByTemplate(templateId, DataStoreRole.Image)).thenReturn(templateDataStoreVO); | |
| systemVmTemplateRegistration.updateTemplateEntriesOnFailure(templateId); | |
| verify(vmTemplateDao).update(templateId, template); | |
| verify(vmTemplateDao).remove(templateId); | |
| verify(templateDataStoreDao).remove(templateDataStoreVO.getId()); | |
| } | |
| @Test | |
| public void updateTemplateEntriesOnFailure_SkipsDataStoreRemovalWhenNotFound() { | |
| long templateId = 1L; | |
| VMTemplateVO template = Mockito.mock(VMTemplateVO.class); | |
| when(vmTemplateDao.createForUpdate(templateId)).thenReturn(template); | |
| when(template.getId()).thenReturn(templateId); | |
| when(templateDataStoreDao.findByTemplate(templateId, DataStoreRole.Image)).thenReturn(null); | |
| systemVmTemplateRegistration.updateTemplateEntriesOnFailure(templateId); | |
| verify(vmTemplateDao).update(templateId, template); | |
| verify(vmTemplateDao).remove(templateId); | |
| verify(templateDataStoreDao, never()).remove(anyLong()); | |
| } | |
| @Test | |
| public void updateConfigurationParams_UpdatesConfigurationSuccessfully() { | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| String templateName = "templateName"; | |
| long zoneId = 1L; | |
| String configName = SystemVmTemplateRegistration.ROUTER_TEMPLATE_CONFIGURATION_NAMES.get(hypervisorType); | |
| when(configurationDao.update(configName, templateName)).thenReturn(true); | |
| when(configurationDao.update(SystemVmTemplateRegistration.MINIMUM_SYSTEM_VM_VERSION_KEY, | |
| systemVmTemplateRegistration.getSystemVmTemplateVersion())).thenReturn(true); | |
| systemVmTemplateRegistration.updateConfigurationParams(hypervisorType, templateName, zoneId); | |
| verify(configurationDao).update(configName, templateName); | |
| verify(dataCenterDetailsDao).removeDetail(zoneId, configName); | |
| verify(configurationDao).update(SystemVmTemplateRegistration.MINIMUM_SYSTEM_VM_VERSION_KEY, | |
| systemVmTemplateRegistration.getSystemVmTemplateVersion()); | |
| verify(dataCenterDetailsDao).removeDetail(zoneId, SystemVmTemplateRegistration.MINIMUM_SYSTEM_VM_VERSION_KEY); | |
| } | |
| @Test | |
| public void updateConfigurationParams_ThrowsExceptionWhenConfigUpdateFails() { | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| String templateName = "templateName"; | |
| Long zoneId = 1L; | |
| String configName = SystemVmTemplateRegistration.ROUTER_TEMPLATE_CONFIGURATION_NAMES.get(hypervisorType); | |
| when(configurationDao.update(configName, templateName)).thenReturn(false); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.updateConfigurationParams(hypervisorType, templateName, zoneId); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to update configuration parameter")); | |
| verify(configurationDao).update(configName, templateName); | |
| verify(dataCenterDetailsDao, never()).removeDetail(anyLong(), anyString()); | |
| } | |
| @Test | |
| public void updateConfigurationParams_SkipsZoneDetailsRemovalWhenZoneIdIsNull() { | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.VMware; | |
| String templateName = "templateName"; | |
| Long zoneId = null; | |
| String configName = SystemVmTemplateRegistration.ROUTER_TEMPLATE_CONFIGURATION_NAMES.get(hypervisorType); | |
| when(configurationDao.update(configName, templateName)).thenReturn(true); | |
| when(configurationDao.update(SystemVmTemplateRegistration.MINIMUM_SYSTEM_VM_VERSION_KEY, | |
| systemVmTemplateRegistration.getSystemVmTemplateVersion())).thenReturn(true); | |
| systemVmTemplateRegistration.updateConfigurationParams(hypervisorType, templateName, zoneId); | |
| verify(configurationDao).update(configName, templateName); | |
| verify(dataCenterDetailsDao, never()).removeDetail(anyLong(), eq(configName)); | |
| verify(configurationDao).update(SystemVmTemplateRegistration.MINIMUM_SYSTEM_VM_VERSION_KEY, | |
| systemVmTemplateRegistration.getSystemVmTemplateVersion()); | |
| verify(dataCenterDetailsDao, never()).removeDetail(anyLong(), | |
| eq(SystemVmTemplateRegistration.MINIMUM_SYSTEM_VM_VERSION_KEY)); | |
| } | |
| @Test | |
| public void createOrUpdateTemplateZoneEntry_CreatesNewEntryWhenNotExists() { | |
| long zoneId = 1L; | |
| long templateId = 100L; | |
| VMTemplateZoneVO newTemplateZoneVO = Mockito.mock(VMTemplateZoneVO.class); | |
| when(vmTemplateZoneDao.findByZoneTemplate(zoneId, templateId)).thenReturn(null); | |
| when(vmTemplateZoneDao.persist(any(VMTemplateZoneVO.class))).thenReturn(newTemplateZoneVO); | |
| VMTemplateZoneVO result = systemVmTemplateRegistration.createOrUpdateTemplateZoneEntry(zoneId, templateId); | |
| assertNotNull(result); | |
| verify(vmTemplateZoneDao).persist(any(VMTemplateZoneVO.class)); | |
| } | |
| @Test | |
| public void createOrUpdateTemplateZoneEntry_UpdatesExistingEntry() { | |
| long zoneId = 1L; | |
| long templateId = 100L; | |
| VMTemplateZoneVO existingTemplateZoneVO = Mockito.mock(VMTemplateZoneVO.class); | |
| when(vmTemplateZoneDao.findByZoneTemplate(zoneId, templateId)).thenReturn(existingTemplateZoneVO); | |
| when(vmTemplateZoneDao.update(existingTemplateZoneVO.getId(), existingTemplateZoneVO)).thenReturn(true); | |
| VMTemplateZoneVO result = systemVmTemplateRegistration.createOrUpdateTemplateZoneEntry(zoneId, templateId); | |
| assertNotNull(result); | |
| verify(vmTemplateZoneDao).update(existingTemplateZoneVO.getId(), existingTemplateZoneVO); | |
| } | |
| @Test | |
| public void createOrUpdateTemplateZoneEntry_ReturnsNullWhenUpdateFails() { | |
| long zoneId = 1L; | |
| long templateId = 100L; | |
| VMTemplateZoneVO existingTemplateZoneVO = Mockito.mock(VMTemplateZoneVO.class); | |
| when(vmTemplateZoneDao.findByZoneTemplate(zoneId, templateId)).thenReturn(existingTemplateZoneVO); | |
| when(vmTemplateZoneDao.update(existingTemplateZoneVO.getId(), existingTemplateZoneVO)).thenReturn(false); | |
| VMTemplateZoneVO result = systemVmTemplateRegistration.createOrUpdateTemplateZoneEntry(zoneId, templateId); | |
| assertNull(result); | |
| verify(vmTemplateZoneDao).update(existingTemplateZoneVO.getId(), existingTemplateZoneVO); | |
| } | |
| @Test | |
| public void createCrossZonesTemplateZoneRefEntries_ThrowsExceptionWhenEntryCreationFails() { | |
| long templateId = 100L; | |
| DataCenterVO dataCenter = Mockito.mock(DataCenterVO.class); | |
| List<DataCenterVO> dataCenters = List.of(dataCenter); | |
| when(dataCenter.getId()).thenReturn(1L); | |
| when(dataCenterDao.listAll()).thenReturn(dataCenters); | |
| when(systemVmTemplateRegistration.createOrUpdateTemplateZoneEntry(1L, templateId)).thenReturn(null); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.createCrossZonesTemplateZoneRefEntries(templateId); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to create template-zone record")); | |
| } | |
| @Test | |
| public void createTemplateStoreRefEntry_CreatesEntrySuccessfully() { | |
| SystemVmTemplateRegistration.SystemVMTemplateDetails details = Mockito.mock(SystemVmTemplateRegistration.SystemVMTemplateDetails.class); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| when(details.getStoreId()).thenReturn(1L); | |
| when(details.getId()).thenReturn(100L); | |
| when(templateDataStoreDao.persist(any(TemplateDataStoreVO.class))).thenReturn(templateDataStoreVO); | |
| systemVmTemplateRegistration.createTemplateStoreRefEntry(details); | |
| verify(templateDataStoreDao).persist(any(TemplateDataStoreVO.class)); | |
| } | |
| @Test | |
| public void createTemplateStoreRefEntry_ThrowsExceptionWhenCreationFails() { | |
| SystemVmTemplateRegistration.SystemVMTemplateDetails details = Mockito.mock(SystemVmTemplateRegistration.SystemVMTemplateDetails.class); | |
| when(details.getStoreId()).thenReturn(1L); | |
| when(details.getId()).thenReturn(100L); | |
| when(templateDataStoreDao.persist(any(TemplateDataStoreVO.class))).thenReturn(null); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.createTemplateStoreRefEntry(details); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to create template-store record")); | |
| } | |
| @Test | |
| public void updateTemplateDetails_UpdatesTemplateAndStoreSuccessfully() { | |
| SystemVmTemplateRegistration.SystemVMTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.SystemVMTemplateDetails.class); | |
| VMTemplateVO template = Mockito.mock(VMTemplateVO.class); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| when(details.getId()).thenReturn(1L); | |
| when(details.getStoreId()).thenReturn(2L); | |
| when(details.getSize()).thenReturn(1024L); | |
| when(details.getPhysicalSize()).thenReturn(2048L); | |
| when(template.getId()).thenReturn(1L); | |
| when(vmTemplateDao.findById(1L)).thenReturn(template); | |
| when(templateDataStoreDao.findByStoreTemplate(2L, 1L)).thenReturn(templateDataStoreVO); | |
| when(templateDataStoreDao.update(anyLong(), any(TemplateDataStoreVO.class))).thenReturn(true); | |
| systemVmTemplateRegistration.updateTemplateDetails(details); | |
| verify(template).setSize(1024L); | |
| verify(template).setState(VirtualMachineTemplate.State.Active); | |
| verify(vmTemplateDao).update(template.getId(), template); | |
| verify(templateDataStoreVO).setSize(1024L); | |
| verify(templateDataStoreVO).setPhysicalSize(2048L); | |
| verify(templateDataStoreVO).setDownloadPercent(100); | |
| verify(templateDataStoreVO).setDownloadState(VMTemplateStorageResourceAssoc.Status.DOWNLOADED); | |
| verify(templateDataStoreVO).setLastUpdated(details.getUpdated()); | |
| verify(templateDataStoreVO).setState(ObjectInDataStoreStateMachine.State.Ready); | |
| verify(templateDataStoreDao).update(templateDataStoreVO.getId(), templateDataStoreVO); | |
| } | |
| @Test | |
| public void updateTemplateDetails_ThrowsExceptionWhenStoreUpdateFails() { | |
| SystemVmTemplateRegistration.SystemVMTemplateDetails details = | |
| Mockito.mock(SystemVmTemplateRegistration.SystemVMTemplateDetails.class); | |
| VMTemplateVO template = Mockito.mock(VMTemplateVO.class); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| when(details.getId()).thenReturn(1L); | |
| when(details.getStoreId()).thenReturn(2L); | |
| when(details.getSize()).thenReturn(1024L); | |
| when(details.getPhysicalSize()).thenReturn(2048L); | |
| when(template.getId()).thenReturn(1L); | |
| when(vmTemplateDao.findById(1L)).thenReturn(template); | |
| when(templateDataStoreDao.findByStoreTemplate(2L, 1L)).thenReturn(templateDataStoreVO); | |
| when(templateDataStoreDao.update(anyLong(), any(TemplateDataStoreVO.class))).thenReturn(false); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.updateTemplateDetails(details); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to update template-store record")); | |
| verify(templateDataStoreDao).update(templateDataStoreVO.getId(), templateDataStoreVO); | |
| } | |
| @Test | |
| public void getNfsStoreInZone_ReturnsStoreDetailsWhenStoreExists() { | |
| long zoneId = 1L; | |
| ImageStoreVO storeVO = Mockito.mock(ImageStoreVO.class); | |
| when(imageStoreDao.findOneByZoneAndProtocol(zoneId, "nfs")).thenReturn(storeVO); | |
| when(storeVO.getUrl()).thenReturn("nfs://example.com/store"); | |
| when(storeVO.getId()).thenReturn(100L); | |
| Pair<String, Long> result = systemVmTemplateRegistration.getNfsStoreInZone(zoneId); | |
| assertNotNull(result); | |
| assertEquals("nfs://example.com/store", result.first()); | |
| assertEquals(100L, result.second().longValue()); | |
| } | |
| @Test | |
| public void getNfsStoreInZone_ThrowsExceptionWhenStoreNotFound() { | |
| long zoneId = 1L; | |
| when(imageStoreDao.findOneByZoneAndProtocol(zoneId, "nfs")).thenReturn(null); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.getNfsStoreInZone(zoneId); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to fetch NFS store in zone")); | |
| } | |
| @Test | |
| public void readTemplateProperties_SetsTemplateSizesCorrectly() { | |
| String path = "/template/path"; | |
| SystemVmTemplateRegistration.SystemVMTemplateDetails details = Mockito.mock(SystemVmTemplateRegistration.SystemVMTemplateDetails.class); | |
| Pair<Long, Long> templateSizes = new Pair<>(1024L, 2048L); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.readTemplatePropertiesSizes(path)).thenReturn(templateSizes); | |
| systemVmTemplateRegistration.readTemplateProperties(path, details); | |
| verify(details).setSize(1024L); | |
| verify(details).setPhysicalSize(2048L); | |
| } | |
| } | |
| @Test | |
| public void readTemplateProperties_ThrowsExceptionWhenPathIsInvalid() { | |
| String path = "/invalid/path"; | |
| SystemVmTemplateRegistration.SystemVMTemplateDetails details = Mockito.mock(SystemVmTemplateRegistration.SystemVMTemplateDetails.class); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.readTemplatePropertiesSizes(path)) | |
| .thenThrow(new CloudRuntimeException("Invalid path")); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.readTemplateProperties(path, details); | |
| }); | |
| assertTrue(exception.getMessage().contains("Invalid path")); | |
| } | |
| } | |
| @Test | |
| public void getEligibleZoneIds_ReturnsUniqueZoneIds() { | |
| ImageStoreVO store1 = Mockito.mock(ImageStoreVO.class); | |
| ImageStoreVO store2 = Mockito.mock(ImageStoreVO.class); | |
| ImageStoreVO store3 = Mockito.mock(ImageStoreVO.class); | |
| when(store1.getDataCenterId()).thenReturn(1L); | |
| when(store2.getDataCenterId()).thenReturn(2L); | |
| when(store3.getDataCenterId()).thenReturn(1L); | |
| when(imageStoreDao.findByProtocol("nfs")).thenReturn(List.of(store1, store2, store3)); | |
| List<Long> result = systemVmTemplateRegistration.getEligibleZoneIds(); | |
| assertNotNull(result); | |
| assertEquals(2, result.size()); | |
| assertTrue(result.contains(1L)); | |
| assertTrue(result.contains(2L)); | |
| } | |
| @Test | |
| public void getEligibleZoneIds_ReturnsEmptyListWhenNoStoresExist() { | |
| when(imageStoreDao.findByProtocol("nfs")).thenReturn(new ArrayList<>()); | |
| List<Long> result = systemVmTemplateRegistration.getEligibleZoneIds(); | |
| assertNotNull(result); | |
| assertTrue(result.isEmpty()); | |
| } | |
| @Test | |
| public void getNfsVersion_ReturnsStoreSpecificVersionWhenPresent() { | |
| long storeId = 1L; | |
| String configKey = "secstorage.nfs.version"; | |
| String expectedVersion = "nfs4"; | |
| Map<String, String> storeDetails = Map.of(configKey, expectedVersion); | |
| when(imageStoreDetailsDao.getDetails(storeId)).thenReturn(storeDetails); | |
| String result = systemVmTemplateRegistration.getNfsVersion(storeId); | |
| assertNotNull(result); | |
| assertEquals(expectedVersion, result); | |
| } | |
| @Test | |
| public void getNfsVersion_ReturnsGlobalVersionWhenStoreSpecificVersionNotPresent() { | |
| long storeId = 1L; | |
| String expectedVersion = "nfs3"; | |
| ConfigurationVO globalConfig = Mockito.mock(ConfigurationVO.class); | |
| when(imageStoreDetailsDao.getDetails(storeId)).thenReturn(null); | |
| when(configurationDao.findByName(anyString())).thenReturn(globalConfig); | |
| when(globalConfig.getValue()).thenReturn(expectedVersion); | |
| String result = systemVmTemplateRegistration.getNfsVersion(storeId); | |
| assertNotNull(result); | |
| assertEquals(expectedVersion, result); | |
| } | |
| @Test | |
| public void getNfsVersion_ReturnsNullWhenNoVersionConfigured() { | |
| long storeId = 1L; | |
| when(imageStoreDetailsDao.getDetails(storeId)).thenReturn(null); | |
| when(configurationDao.findByName(anyString())).thenReturn(null); | |
| String result = systemVmTemplateRegistration.getNfsVersion(storeId); | |
| assertNull(result); | |
| } | |
| @Test | |
| public void validateIfSeeded_ReturnsTrueWhenTemplateIsSeeded() throws Exception { | |
| TemplateDataStoreVO templDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| String url = "nfs://example.com/store"; | |
| Path local = Files.createTempDirectory("local"); | |
| Files.createDirectory(local.resolve("template")); | |
| String path = "/template/path"; | |
| String nfsVersion = "nfs3"; | |
| Path secondary = Files.createTempDirectory("secondary"); | |
| Files.createDirectory(secondary.resolve("template")); | |
| Files.createFile(secondary.resolve("template").resolve("template.properties")); | |
| String tempDir = secondary.toString(); | |
| Pair<Long, Long> templateSizes = new Pair<>(1024L, 2048L); | |
| when(templDataStoreVO.getTemplateId()).thenReturn(1L); | |
| when(templDataStoreVO.getDataStoreId()).thenReturn(2L); | |
| doNothing().when(systemVmTemplateRegistration).updateSeededTemplateDetails(anyLong(), anyLong(), anyLong(), anyLong()); | |
| try (MockedStatic<Files> filesMock = Mockito.mockStatic(Files.class); | |
| MockedStatic<SystemVmTemplateRegistration> mockedStatic = Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| filesMock.when(() -> Files.createTempDirectory(SystemVmTemplateRegistration.TEMPORARY_SECONDARY_STORE)).thenReturn(Path.of(tempDir)); | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.readTemplatePropertiesSizes(anyString())).thenReturn(templateSizes); | |
| boolean result = systemVmTemplateRegistration.validateIfSeeded(templDataStoreVO, url, path, nfsVersion); | |
| assertTrue(result); | |
| verify(systemVmTemplateRegistration).updateSeededTemplateDetails(1L, 2L, 1024L, 2048L); | |
| } | |
| } | |
| @Test | |
| public void validateIfSeeded_ReturnsFalseWhenTemplateIsNotSeeded() throws Exception { | |
| TemplateDataStoreVO templDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| String url = "nfs://example.com/store"; | |
| String path = "/template/path"; | |
| String nfsVersion = "nfs3"; | |
| String tempDir = "/tmp/secondary"; | |
| try (MockedStatic<Files> filesMock = Mockito.mockStatic(Files.class)) { | |
| filesMock.when(() -> Files.createTempDirectory(SystemVmTemplateRegistration.TEMPORARY_SECONDARY_STORE)).thenReturn(Path.of(tempDir)); | |
| boolean result = systemVmTemplateRegistration.validateIfSeeded(templDataStoreVO, url, path, nfsVersion); | |
| assertFalse(result); | |
| verify(systemVmTemplateRegistration, never()).updateSeededTemplateDetails(anyLong(), anyLong(), anyLong(), anyLong()); | |
| } | |
| } | |
| @Test | |
| public void validateIfSeeded_ThrowsExceptionWhenTempDirectoryCreationFails() { | |
| TemplateDataStoreVO templDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| String url = "nfs://example.com/store"; | |
| String path = "/template/path"; | |
| String nfsVersion = "nfs3"; | |
| try (MockedStatic<Files> filesMock = Mockito.mockStatic(Files.class)) { | |
| filesMock.when(() -> Files.createTempDirectory(SystemVmTemplateRegistration.TEMPORARY_SECONDARY_STORE)).thenThrow(IOException.class); | |
| assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.validateIfSeeded(templDataStoreVO, url, path, nfsVersion); | |
| }); | |
| } | |
| } | |
| @Test | |
| public void validateIfSeeded_ThrowsExceptionWhenUnmountFails() throws Exception { | |
| TemplateDataStoreVO templDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| String url = "nfs://example.com/store"; | |
| String path = "/template/path"; | |
| String nfsVersion = "nfs3"; | |
| String tempDir = "/tmp/secondary"; | |
| try (MockedStatic<Files> filesMock = Mockito.mockStatic(Files.class); | |
| MockedStatic<SystemVmTemplateRegistration> mockedStatic = Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| filesMock.when(() -> Files.createTempDirectory(SystemVmTemplateRegistration.TEMPORARY_SECONDARY_STORE)).thenReturn(Path.of(tempDir)); | |
| mockedStatic.when(() -> SystemVmTemplateRegistration.unmountStore(anyString())).thenThrow(CloudRuntimeException.class); | |
| assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.validateIfSeeded(templDataStoreVO, url, path, nfsVersion); | |
| }); | |
| } | |
| } | |
| @Test | |
| public void registerNewTemplate_RegistersTemplateSuccessfully() { | |
| String name = "templateName"; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getUrl()).thenReturn("a"); | |
| when(templateDetails.getChecksum()).thenReturn("b"); | |
| long zoneId = 1L; | |
| Long storeId = 2L; | |
| String filePath = "/tmp/store"; | |
| Long templateId = 100L; | |
| Hypervisor.HypervisorType hypervisor = Hypervisor.HypervisorType.KVM; | |
| when(templateDetails.getHypervisorType()).thenReturn(hypervisor); | |
| doReturn(templateId).when(systemVmTemplateRegistration) | |
| .performTemplateRegistrationOperations( | |
| name, templateDetails, "a", "b", | |
| SystemVmTemplateRegistration.HYPERVISOR_IMAGE_FORMAT_MAP.get(hypervisor), | |
| SystemVmTemplateRegistration.hypervisorGuestOsMap.get(hypervisor), | |
| storeId, null, filePath, null); | |
| doNothing().when(systemVmTemplateRegistration).updateConfigurationParams(hypervisor, name, zoneId); | |
| doNothing().when(systemVmTemplateRegistration).updateSystemVMEntries(templateId, hypervisor); | |
| systemVmTemplateRegistration.registerNewTemplate(name, templateDetails, zoneId, storeId, filePath); | |
| verify(systemVmTemplateRegistration).performTemplateRegistrationOperations( | |
| name, templateDetails, templateDetails.getUrl(), templateDetails.getChecksum(), | |
| SystemVmTemplateRegistration.HYPERVISOR_IMAGE_FORMAT_MAP.get(hypervisor), | |
| SystemVmTemplateRegistration.hypervisorGuestOsMap.get(hypervisor), | |
| storeId, null, filePath, null); | |
| verify(systemVmTemplateRegistration).updateConfigurationParams(hypervisor, name, zoneId); | |
| verify(systemVmTemplateRegistration).updateSystemVMEntries(templateId, hypervisor); | |
| } | |
| @Test | |
| public void registerNewTemplate_ThrowsExceptionWhenRegistrationFails() { | |
| String name = "templateName"; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getUrl()).thenReturn("a"); | |
| when(templateDetails.getChecksum()).thenReturn("b"); | |
| long zoneId = 1L; | |
| Long storeId = 2L; | |
| String filePath = "/tmp/store"; | |
| Hypervisor.HypervisorType hypervisor = Hypervisor.HypervisorType.KVM; | |
| when(templateDetails.getHypervisorType()).thenReturn(hypervisor); | |
| doThrow(new CloudRuntimeException("Registration failed")).when(systemVmTemplateRegistration) | |
| .performTemplateRegistrationOperations( | |
| name, templateDetails, "a", "b", | |
| SystemVmTemplateRegistration.HYPERVISOR_IMAGE_FORMAT_MAP.get(hypervisor), | |
| SystemVmTemplateRegistration.hypervisorGuestOsMap.get(hypervisor), | |
| storeId, null, filePath, null); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.registerNewTemplate(name, templateDetails, zoneId, storeId, filePath); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to register Template for")); | |
| verify(systemVmTemplateRegistration).performTemplateRegistrationOperations( | |
| name, templateDetails, templateDetails.getUrl(), templateDetails.getChecksum(), | |
| SystemVmTemplateRegistration.HYPERVISOR_IMAGE_FORMAT_MAP.get(hypervisor), | |
| SystemVmTemplateRegistration.hypervisorGuestOsMap.get(hypervisor), | |
| storeId, null, filePath, null); | |
| verify(systemVmTemplateRegistration, never()).updateConfigurationParams(any(), any(), anyLong()); | |
| verify(systemVmTemplateRegistration, never()).updateSystemVMEntries(anyLong(), any()); | |
| } | |
| @Test | |
| public void registerNewTemplate_CleansUpOnFailure() { | |
| String name = "templateName"; | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getUrl()).thenReturn("a"); | |
| when(templateDetails.getChecksum()).thenReturn("b"); | |
| long zoneId = 1L; | |
| Long storeId = 2L; | |
| String filePath = "/tmp/store"; | |
| Long templateId = 100L; | |
| Hypervisor.HypervisorType hypervisor = Hypervisor.HypervisorType.KVM; | |
| when(templateDetails.getHypervisorType()).thenReturn(hypervisor); | |
| doReturn(templateId).when(systemVmTemplateRegistration) | |
| .performTemplateRegistrationOperations( | |
| name, templateDetails, "a", "b", | |
| SystemVmTemplateRegistration.HYPERVISOR_IMAGE_FORMAT_MAP.get(hypervisor), | |
| SystemVmTemplateRegistration.hypervisorGuestOsMap.get(hypervisor), | |
| storeId, null, filePath, null); | |
| doThrow(new CloudRuntimeException("Update failed")).when(systemVmTemplateRegistration) | |
| .updateConfigurationParams(hypervisor, name, zoneId); | |
| doNothing().when(systemVmTemplateRegistration).updateTemplateEntriesOnFailure(templateId); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.registerNewTemplate(name, templateDetails, zoneId, storeId, filePath); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to register Template for")); | |
| verify(systemVmTemplateRegistration).updateTemplateEntriesOnFailure(templateId); | |
| mockedStatic.verify(() -> SystemVmTemplateRegistration.cleanupStore(templateId, filePath)); | |
| } | |
| } | |
| @Test | |
| public void addExistingTemplateToStore_AddsTemplateSuccessfully() { | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| when(templateVO.getId()).thenReturn(1L); | |
| when(templateVO.getName()).thenReturn("templateName"); | |
| when(templateVO.getUrl()).thenReturn("http://example.com/template"); | |
| when(templateVO.getChecksum()).thenReturn("abc123"); | |
| when(templateVO.getFormat()).thenReturn(Storage.ImageFormat.QCOW2); | |
| when(templateVO.getGuestOSId()).thenReturn(1L); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| long zoneId = 1L; | |
| Long storeId = 2L; | |
| String filePath = "/tmp/store"; | |
| doReturn(1L).when(systemVmTemplateRegistration) | |
| .performTemplateRegistrationOperations("templateName", templateDetails, | |
| "http://example.com/template", "abc123", Storage.ImageFormat.QCOW2, | |
| 1L, storeId, 1L, filePath, templateDataStoreVO); | |
| systemVmTemplateRegistration.addExistingTemplateToStore(templateVO, templateDetails, templateDataStoreVO, zoneId, storeId, filePath); | |
| verify(systemVmTemplateRegistration).performTemplateRegistrationOperations( | |
| templateVO.getName(), templateDetails, templateVO.getUrl(), templateVO.getChecksum(), | |
| templateVO.getFormat(), templateVO.getGuestOSId(), storeId, templateVO.getId(), filePath, templateDataStoreVO); | |
| } | |
| @Test | |
| public void addExistingTemplateToStore_CleansUpOnFailure() { | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| when(templateVO.getId()).thenReturn(1L); | |
| when(templateVO.getName()).thenReturn("templateName"); | |
| when(templateVO.getUrl()).thenReturn("http://example.com/template"); | |
| when(templateVO.getChecksum()).thenReturn("abc123"); | |
| when(templateVO.getFormat()).thenReturn(Storage.ImageFormat.QCOW2); | |
| when(templateVO.getGuestOSId()).thenReturn(1L); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = | |
| Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| long zoneId = 1L; | |
| Long storeId = 2L; | |
| String filePath = "/tmp/store"; | |
| doThrow(new CloudRuntimeException("Operation failed")).when(systemVmTemplateRegistration) | |
| .performTemplateRegistrationOperations("templateName", templateDetails, | |
| "http://example.com/template", "abc123", Storage.ImageFormat.QCOW2, | |
| 1L, storeId, 1L, filePath, templateDataStoreVO); | |
| try (MockedStatic<SystemVmTemplateRegistration> mockedStatic = | |
| Mockito.mockStatic(SystemVmTemplateRegistration.class)) { | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.addExistingTemplateToStore(templateVO, templateDetails, templateDataStoreVO, zoneId, storeId, filePath); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to add")); | |
| mockedStatic.verify(() -> SystemVmTemplateRegistration.cleanupStore(templateVO.getId(), filePath)); | |
| } | |
| } | |
| @Test | |
| public void updateSeededTemplateDetails_UpdatesTemplateAndStoreSuccessfully() { | |
| long templateId = 1L; | |
| long storeId = 2L; | |
| long size = 1024L; | |
| long physicalSize = 2048L; | |
| VMTemplateVO template = Mockito.mock(VMTemplateVO.class); | |
| when(template.getId()).thenReturn(templateId); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| when(vmTemplateDao.findById(templateId)).thenReturn(template); | |
| when(templateDataStoreDao.findByStoreTemplate(storeId, templateId)).thenReturn(templateDataStoreVO); | |
| when(templateDataStoreDao.update(anyLong(), any(TemplateDataStoreVO.class))).thenReturn(true); | |
| systemVmTemplateRegistration.updateSeededTemplateDetails(templateId, storeId, size, physicalSize); | |
| verify(template).setSize(size); | |
| verify(vmTemplateDao).update(template.getId(), template); | |
| verify(templateDataStoreVO).setSize(size); | |
| verify(templateDataStoreVO).setPhysicalSize(physicalSize); | |
| verify(templateDataStoreVO).setLastUpdated(any(Date.class)); | |
| verify(templateDataStoreDao).update(templateDataStoreVO.getId(), templateDataStoreVO); | |
| } | |
| @Test | |
| public void updateSeededTemplateDetails_ThrowsExceptionWhenStoreUpdateFails() { | |
| long templateId = 1L; | |
| long storeId = 2L; | |
| long size = 1024L; | |
| long physicalSize = 2048L; | |
| VMTemplateVO template = Mockito.mock(VMTemplateVO.class); | |
| when(template.getId()).thenReturn(templateId); | |
| TemplateDataStoreVO templateDataStoreVO = Mockito.mock(TemplateDataStoreVO.class); | |
| when(vmTemplateDao.findById(templateId)).thenReturn(template); | |
| when(templateDataStoreDao.findByStoreTemplate(storeId, templateId)).thenReturn(templateDataStoreVO); | |
| when(templateDataStoreDao.update(anyLong(), any(TemplateDataStoreVO.class))).thenReturn(false); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.updateSeededTemplateDetails(templateId, storeId, size, physicalSize); | |
| }); | |
| assertTrue(exception.getMessage().contains("Failed to update template-store record for seeded system VM Template")); | |
| verify(templateDataStoreDao).update(templateDataStoreVO.getId(), templateDataStoreVO); | |
| } | |
| @Test | |
| public void updateSystemVMEntries_UpdatesTemplateIdSuccessfully() { | |
| long templateId = 1L; | |
| Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM; | |
| systemVmTemplateRegistration.updateSystemVMEntries(templateId, hypervisorType); | |
| verify(vmInstanceDao).updateSystemVmTemplateId(templateId, hypervisorType); | |
| } | |
| @Test | |
| public void updateHypervisorGuestOsMap_UpdatesGuestOsMapSuccessfully() { | |
| GuestOSVO guestOS = Mockito.mock(GuestOSVO.class); | |
| when(guestOS.getId()).thenReturn(10L); | |
| when(guestOSDao.findOneByDisplayName(DEFAULT_SYSTEM_VM_GUEST_OS_NAME)).thenReturn(guestOS); | |
| systemVmTemplateRegistration.updateHypervisorGuestOsMap(); | |
| verify(guestOSDao).findOneByDisplayName(DEFAULT_SYSTEM_VM_GUEST_OS_NAME); | |
| assertEquals(10, SystemVmTemplateRegistration.LINUX_12_ID.intValue()); | |
| assertEquals(10, SystemVmTemplateRegistration.hypervisorGuestOsMap.get(Hypervisor.HypervisorType.KVM).intValue()); | |
| assertEquals(10, SystemVmTemplateRegistration.hypervisorGuestOsMap.get(Hypervisor.HypervisorType.Hyperv).intValue()); | |
| assertEquals(10, SystemVmTemplateRegistration.hypervisorGuestOsMap.get(Hypervisor.HypervisorType.LXC).intValue()); | |
| assertEquals(10, SystemVmTemplateRegistration.hypervisorGuestOsMap.get(Hypervisor.HypervisorType.Ovm3).intValue()); | |
| } | |
| @Test | |
| public void updateHypervisorGuestOsMap_SkipsUpdateWhenGuestOsNotFound() { | |
| Integer value = SystemVmTemplateRegistration.hypervisorGuestOsMap.get(Hypervisor.HypervisorType.KVM); | |
| when(guestOSDao.findOneByDisplayName(DEFAULT_SYSTEM_VM_GUEST_OS_NAME)).thenReturn(null); | |
| systemVmTemplateRegistration.updateHypervisorGuestOsMap(); | |
| verify(guestOSDao).findOneByDisplayName(DEFAULT_SYSTEM_VM_GUEST_OS_NAME); | |
| assertEquals(value, SystemVmTemplateRegistration.hypervisorGuestOsMap.get(Hypervisor.HypervisorType.KVM)); | |
| } | |
| @Test | |
| public void updateHypervisorGuestOsMap_LogsWarningOnException() { | |
| when(guestOSDao.findOneByDisplayName(DEFAULT_SYSTEM_VM_GUEST_OS_NAME)).thenThrow(new RuntimeException("Database error")); | |
| systemVmTemplateRegistration.updateHypervisorGuestOsMap(); | |
| verify(guestOSDao).findOneByDisplayName(DEFAULT_SYSTEM_VM_GUEST_OS_NAME); | |
| } | |
| @Test | |
| public void updateTemplateUrlChecksumAndGuestOsId_UpdatesSuccessfully() { | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| GuestOSVO guestOS = Mockito.mock(GuestOSVO.class); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| when(templateDetails.getChecksum()).thenReturn("abc123"); | |
| when(templateDetails.getGuestOs()).thenReturn("Debian"); | |
| when(guestOSDao.findOneByDisplayName("Debian")).thenReturn(guestOS); | |
| when(guestOS.getId()).thenReturn(10L); | |
| when(templateVO.getId()).thenReturn(1L); | |
| when(vmTemplateDao.update(templateVO.getId(), templateVO)).thenReturn(true); | |
| systemVmTemplateRegistration.updateTemplateUrlChecksumAndGuestOsId(templateVO, templateDetails); | |
| verify(templateVO).setUrl("http://example.com/template"); | |
| verify(templateVO).setChecksum("abc123"); | |
| verify(templateVO).setGuestOSId(10L); | |
| verify(vmTemplateDao).update(templateVO.getId(), templateVO); | |
| } | |
| @Test | |
| public void updateTemplateUrlChecksumAndGuestOsId_SkipsGuestOsUpdateWhenNotFound() { | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| when(templateDetails.getChecksum()).thenReturn("abc123"); | |
| when(templateDetails.getGuestOs()).thenReturn("NonExistentOS"); | |
| when(guestOSDao.findOneByDisplayName("NonExistentOS")).thenReturn(null); | |
| when(templateVO.getId()).thenReturn(1L); | |
| when(vmTemplateDao.update(templateVO.getId(), templateVO)).thenReturn(true); | |
| systemVmTemplateRegistration.updateTemplateUrlChecksumAndGuestOsId(templateVO, templateDetails); | |
| verify(templateVO).setUrl("http://example.com/template"); | |
| verify(templateVO).setChecksum("abc123"); | |
| verify(templateVO, never()).setGuestOSId(anyLong()); | |
| verify(vmTemplateDao).update(templateVO.getId(), templateVO); | |
| } | |
| @Test | |
| public void updateTemplateUrlChecksumAndGuestOsId_ThrowsExceptionWhenUpdateFails() { | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| SystemVmTemplateRegistration.MetadataTemplateDetails templateDetails = Mockito.mock(SystemVmTemplateRegistration.MetadataTemplateDetails.class); | |
| when(templateDetails.getUrl()).thenReturn("http://example.com/template"); | |
| when(templateDetails.getChecksum()).thenReturn("abc123"); | |
| when(templateDetails.getGuestOs()).thenReturn("Debian"); | |
| when(templateVO.getId()).thenReturn(1L); | |
| when(vmTemplateDao.update(templateVO.getId(), templateVO)).thenReturn(false); | |
| CloudRuntimeException exception = assertThrows(CloudRuntimeException.class, () -> { | |
| systemVmTemplateRegistration.updateTemplateUrlChecksumAndGuestOsId(templateVO, templateDetails); | |
| }); | |
| assertTrue(exception.getMessage().contains("Exception while updating 'url' and 'checksum' for hypervisor type")); | |
| verify(vmTemplateDao).update(templateVO.getId(), templateVO); | |
| } | |
| @Test | |
| public void getSystemVmTemplateVersion_UsesExplicitVersionWhenSet() { | |
| SystemVmTemplateRegistration registration = new SystemVmTemplateRegistration("4.22.0.0"); | |
| assertEquals("4.22.0.0", registration.getSystemVmTemplateVersion()); | |
| } | |
| @Test | |
| public void getSystemVmTemplateVersion_BuildsFromMajorAndTinyVersionBelowCutover() { | |
| String previousMajor = SystemVmTemplateRegistration.CS_MAJOR_VERSION; | |
| String previousTiny = SystemVmTemplateRegistration.CS_TINY_VERSION; | |
| try { | |
| SystemVmTemplateRegistration.CS_MAJOR_VERSION = "4.22"; | |
| SystemVmTemplateRegistration.CS_TINY_VERSION = "1"; | |
| assertEquals("4.22.1", systemVmTemplateRegistration.getSystemVmTemplateVersion()); | |
| } finally { | |
| SystemVmTemplateRegistration.CS_MAJOR_VERSION = previousMajor; | |
| SystemVmTemplateRegistration.CS_TINY_VERSION = previousTiny; | |
| } | |
| } | |
| @Test | |
| public void getSystemVmTemplateVersion_BuildsFromMajorAndTinyVersionAfterCutover() { | |
| String previousMajor = SystemVmTemplateRegistration.CS_MAJOR_VERSION; | |
| String previousTiny = SystemVmTemplateRegistration.CS_TINY_VERSION; | |
| try { | |
| SystemVmTemplateRegistration.CS_MAJOR_VERSION = "24.0"; | |
| SystemVmTemplateRegistration.CS_TINY_VERSION = "1"; | |
| assertEquals("24.0.1", systemVmTemplateRegistration.getSystemVmTemplateVersion()); | |
| } finally { | |
| SystemVmTemplateRegistration.CS_MAJOR_VERSION = previousMajor; | |
| SystemVmTemplateRegistration.CS_TINY_VERSION = previousTiny; | |
| } | |
| } | |
| } |