This is an automated email from the ASF dual-hosted git repository. dahn pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/cloudstack.git
commit 2149e82856f4f658dcec5200430a2ac175b07c91 Merge: 0efa4f6e51 147ea06af3 Author: Daan Hoogland <[email protected]> AuthorDate: Wed Feb 8 15:50:11 2023 +0100 Merge release branch 4.17 to main .../com/cloud/vm/VirtualMachineManagerImpl.java | 4 ++ .../cloud/vm/VirtualMachineManagerImplTest.java | 7 ++++ .../main/java/com/cloud/vm/UserVmManagerImpl.java | 4 ++ .../deployment/RouterDeploymentDefinition.java | 2 +- .../java/com/cloud/vm/UserVmManagerImplTest.java | 47 ++++++++++++++++++++-- .../compute/wizard/SecurityGroupSelection.vue | 5 ++- 6 files changed, 62 insertions(+), 7 deletions(-) diff --cc server/src/test/java/com/cloud/vm/UserVmManagerImplTest.java index 06a56e45f1,550532b318..77a8b3db9a --- a/server/src/test/java/com/cloud/vm/UserVmManagerImplTest.java +++ b/server/src/test/java/com/cloud/vm/UserVmManagerImplTest.java @@@ -25,9 -23,8 +25,10 @@@ import static org.mockito.ArgumentMatch import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.anyString; + import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.nullable; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.lenient; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@@ -37,13 -34,8 +38,14 @@@ import java.util.HashMap import java.util.List; import java.util.Map; +import com.cloud.template.VirtualMachineTemplate; +import com.cloud.user.UserData; +import com.cloud.user.UserDataVO; +import com.cloud.user.dao.UserDataDao; +import com.cloud.utils.exception.CloudRuntimeException; import org.apache.cloudstack.api.BaseCmd.HTTPMethod; +import org.apache.cloudstack.api.command.user.vm.ResetVMUserDataCmd; + import org.apache.cloudstack.api.command.user.vm.DeployVMCmd; import org.apache.cloudstack.api.command.user.vm.UpdateVMCmd; import org.apache.cloudstack.api.command.user.volume.ResizeVolumeCmd; import org.apache.cloudstack.context.CallContext; @@@ -165,16 -168,16 +178,25 @@@ public class UserVmManagerImplTest @Mock VolumeApiService volumeApiService; + @Mock + UserDataDao userDataDao; + + @Mock + private VolumeVO volumeVOMock; + + @Mock + private VolumeDao volumeDaoMock; + - private long vmId = 1l; + @Mock + AccountVO account; + + @Mock + private ServiceOfferingVO serviceOffering; + + private static final long vmId = 1l; + private static final long zoneId = 2L; + private static final long accountId = 3L; + private static final long serviceOfferingId = 10L; private static final long GiB_TO_BYTES = 1024 * 1024 * 1024; @@@ -624,254 -596,19 +646,271 @@@ return newRootDiskOffering; } ++<<<<<<< HEAD + private ServiceOfferingVO prepareOfferingsForEncryptionValidation(long diskOfferingId, boolean encryption) { + ServiceOfferingVO svcOffering = Mockito.mock(ServiceOfferingVO.class); + DiskOfferingVO diskOffering = Mockito.mock(DiskOfferingVO.class); + + Mockito.when(svcOffering.getDiskOfferingId()).thenReturn(diskOfferingId); + Mockito.when(diskOffering.getEncrypt()).thenReturn(encryption); + + // Be aware - Multiple calls with the same disk offering ID could conflict + Mockito.when(diskOfferingDao.findByIdIncludingRemoved(diskOfferingId)).thenReturn(diskOffering); + Mockito.when(diskOfferingDao.findById(diskOfferingId)).thenReturn(diskOffering); + + return svcOffering; + } + + @Test (expected = CloudRuntimeException.class) + public void testUserDataDenyOverride() { + Long userDataId = 1L; + + VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class); + when(template.getUserDataId()).thenReturn(2L); + when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.DENYOVERRIDE); + + userVmManagerImpl.finalizeUserData(null, userDataId, template); + } + + @Test + public void testUserDataAllowOverride() { + String templateUserData = "testTemplateUserdata"; + Long userDataId = 1L; + + VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class); + when(template.getUserDataId()).thenReturn(2L); + when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.ALLOWOVERRIDE); + + UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class); + doReturn(apiUserDataVO).when(userDataDao).findById(userDataId); + when(apiUserDataVO.getUserData()).thenReturn(templateUserData); + + String finalUserdata = userVmManagerImpl.finalizeUserData(null, userDataId, template); + + Assert.assertEquals(finalUserdata, templateUserData); + } + + @Test + public void testUserDataAppend() { + String userData = "testUserdata"; + String templateUserData = "testTemplateUserdata"; + Long userDataId = 1L; + + VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class); + when(template.getUserDataId()).thenReturn(2L); + when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.APPEND); + + UserDataVO templateUserDataVO = Mockito.mock(UserDataVO.class); + doReturn(templateUserDataVO).when(userDataDao).findById(2L); + when(templateUserDataVO.getUserData()).thenReturn(templateUserData); + + UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class); + doReturn(apiUserDataVO).when(userDataDao).findById(userDataId); + when(apiUserDataVO.getUserData()).thenReturn(userData); + + String finalUserdata = userVmManagerImpl.finalizeUserData(null, userDataId, template); + + Assert.assertEquals(finalUserdata, templateUserData+userData); + } + + @Test + public void testUserDataWithoutTemplate() { + String userData = "testUserdata"; + Long userDataId = 1L; + + UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class); + doReturn(apiUserDataVO).when(userDataDao).findById(userDataId); + when(apiUserDataVO.getUserData()).thenReturn(userData); + + VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class); + when(template.getUserDataId()).thenReturn(null); + + String finalUserdata = userVmManagerImpl.finalizeUserData(null, userDataId, template); + + Assert.assertEquals(finalUserdata, userData); + } + + @Test + public void testUserDataAllowOverrideWithoutAPIuserdata() { + String templateUserData = "testTemplateUserdata"; + + VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class); + when(template.getUserDataId()).thenReturn(2L); + when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.ALLOWOVERRIDE); + UserDataVO templateUserDataVO = Mockito.mock(UserDataVO.class); + doReturn(templateUserDataVO).when(userDataDao).findById(2L); + when(templateUserDataVO.getUserData()).thenReturn(templateUserData); + + String finalUserdata = userVmManagerImpl.finalizeUserData(null, null, template); + + Assert.assertEquals(finalUserdata, templateUserData); + } + + @Test + public void testUserDataAllowOverrideWithUserdataText() { + String userData = "testUserdata"; + VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class); + when(template.getUserDataId()).thenReturn(null); + + String finalUserdata = userVmManagerImpl.finalizeUserData(userData, null, template); + + Assert.assertEquals(finalUserdata, userData); + } + + @Test(expected = InvalidParameterValueException.class) + @PrepareForTest(CallContext.class) + public void testResetVMUserDataVMStateNotStopped() { + CallContext callContextMock = Mockito.mock(CallContext.class); + Mockito.lenient().doReturn(accountMock).when(callContextMock).getCallingAccount(); + + ResetVMUserDataCmd cmd = Mockito.mock(ResetVMUserDataCmd.class); + when(cmd.getId()).thenReturn(1L); + when(userVmDao.findById(1L)).thenReturn(userVmVoMock); + + VMTemplateVO template = Mockito.mock(VMTemplateVO.class); + when(userVmVoMock.getTemplateId()).thenReturn(2L); + when(templateDao.findByIdIncludingRemoved(2L)).thenReturn(template); + + + when(userVmVoMock.getState()).thenReturn(VirtualMachine.State.Running); + + try { + userVmManagerImpl.resetVMUserData(cmd); + } catch (ResourceUnavailableException e) { + throw new RuntimeException(e); + } catch (InsufficientCapacityException e) { + throw new RuntimeException(e); + } + } + + @Test(expected = InvalidParameterValueException.class) + @PrepareForTest(CallContext.class) + public void testResetVMUserDataDontAcceptBothUserdataAndUserdataId() { + CallContext callContextMock = Mockito.mock(CallContext.class); + Mockito.lenient().doReturn(accountMock).when(callContextMock).getCallingAccount(); + + ResetVMUserDataCmd cmd = Mockito.mock(ResetVMUserDataCmd.class); + when(cmd.getId()).thenReturn(1L); + when(userVmDao.findById(1L)).thenReturn(userVmVoMock); + + VMTemplateVO template = Mockito.mock(VMTemplateVO.class); + when(userVmVoMock.getTemplateId()).thenReturn(2L); + when(templateDao.findByIdIncludingRemoved(2L)).thenReturn(template); + + + when(userVmVoMock.getState()).thenReturn(VirtualMachine.State.Stopped); + + when(cmd.getUserData()).thenReturn("testUserdata"); + when(cmd.getUserdataId()).thenReturn(1L); + + try { + userVmManagerImpl.resetVMUserData(cmd); + } catch (ResourceUnavailableException e) { + throw new RuntimeException(e); + } catch (InsufficientCapacityException e) { + throw new RuntimeException(e); + } + } + + @Test + @PrepareForTest(CallContext.class) + public void testResetVMUserDataSuccessResetWithUserdata() { + CallContext callContextMock = Mockito.mock(CallContext.class); + Mockito.lenient().doReturn(accountMock).when(callContextMock).getCallingAccount(); + + UserVmVO userVmVO = new UserVmVO(); + userVmVO.setTemplateId(2L); + userVmVO.setState(VirtualMachine.State.Stopped); + userVmVO.setUserDataId(100L); + userVmVO.setUserData("RandomUserdata"); + + ResetVMUserDataCmd cmd = Mockito.mock(ResetVMUserDataCmd.class); + when(cmd.getId()).thenReturn(1L); + when(userVmDao.findById(1L)).thenReturn(userVmVO); + + VMTemplateVO template = Mockito.mock(VMTemplateVO.class); + when(templateDao.findByIdIncludingRemoved(2L)).thenReturn(template); + when(template.getUserDataId()).thenReturn(null); + + when(cmd.getUserData()).thenReturn("testUserdata"); + when(cmd.getUserdataId()).thenReturn(null); + when(cmd.getHttpMethod()).thenReturn(HTTPMethod.GET); + + try { + doNothing().when(userVmManagerImpl).updateUserData(userVmVO); + userVmManagerImpl.resetVMUserData(cmd); + } catch (ResourceUnavailableException e) { + throw new RuntimeException(e); + } catch (InsufficientCapacityException e) { + throw new RuntimeException(e); + } + + Assert.assertEquals("testUserdata", userVmVO.getUserData()); + Assert.assertEquals(null, userVmVO.getUserDataId()); + } + + @Test + @PrepareForTest(CallContext.class) + public void testResetVMUserDataSuccessResetWithUserdataId() { + CallContext callContextMock = Mockito.mock(CallContext.class); + Mockito.lenient().doReturn(accountMock).when(callContextMock).getCallingAccount(); + + UserVmVO userVmVO = new UserVmVO(); + userVmVO.setTemplateId(2L); + userVmVO.setState(VirtualMachine.State.Stopped); + userVmVO.setUserDataId(100L); + userVmVO.setUserData("RandomUserdata"); + + ResetVMUserDataCmd cmd = Mockito.mock(ResetVMUserDataCmd.class); + when(cmd.getId()).thenReturn(1L); + when(userVmDao.findById(1L)).thenReturn(userVmVO); + + VMTemplateVO template = Mockito.mock(VMTemplateVO.class); + when(templateDao.findByIdIncludingRemoved(2L)).thenReturn(template); + when(template.getUserDataId()).thenReturn(null); + + when(cmd.getUserdataId()).thenReturn(1L); + UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class); + when(userDataDao.findById(1L)).thenReturn(apiUserDataVO); + when(apiUserDataVO.getUserData()).thenReturn("testUserdata"); + when(cmd.getHttpMethod()).thenReturn(HTTPMethod.GET); + + try { + doNothing().when(userVmManagerImpl).updateUserData(userVmVO); + userVmManagerImpl.resetVMUserData(cmd); + } catch (ResourceUnavailableException e) { + throw new RuntimeException(e); + } catch (InsufficientCapacityException e) { + throw new RuntimeException(e); + } + + Assert.assertEquals("testUserdata", userVmVO.getUserData()); + Assert.assertEquals(1L, (long)userVmVO.getUserDataId()); + } + + @Test + public void recoverRootVolumeTestDestroyState() { + Mockito.doReturn(Volume.State.Destroy).when(volumeVOMock).getState(); + + userVmManagerImpl.recoverRootVolume(volumeVOMock, vmId); + + Mockito.verify(volumeApiService).recoverVolume(volumeVOMock.getId()); + Mockito.verify(volumeDaoMock).attachVolume(volumeVOMock.getId(), vmId, UserVmManagerImpl.ROOT_DEVICE_ID); + } ++ + @Test(expected = InvalidParameterValueException.class) + public void createVirtualMachineWithInactiveServiceOffering() throws ResourceUnavailableException, InsufficientCapacityException, ResourceAllocationException { + DeployVMCmd deployVMCmd = new DeployVMCmd(); + ReflectionTestUtils.setField(deployVMCmd, "zoneId", zoneId); + ReflectionTestUtils.setField(deployVMCmd, "serviceOfferingId", serviceOfferingId); + deployVMCmd._accountService = accountService; + + when(accountService.finalyzeAccountId(nullable(String.class), nullable(Long.class), nullable(Long.class), eq(true))).thenReturn(accountId); + when(accountService.getActiveAccountById(accountId)).thenReturn(account); + when(entityManager.findById(DataCenter.class, zoneId)).thenReturn(_dcMock); + when(entityManager.findById(ServiceOffering.class, serviceOfferingId)).thenReturn(serviceOffering); + when(serviceOffering.getState()).thenReturn(ServiceOffering.State.Inactive); + + userVmManagerImpl.createVirtualMachine(deployVMCmd); + } }
