mirror of https://github.com/apache/cloudstack.git
931 lines
41 KiB
Java
931 lines
41 KiB
Java
// 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.vm;
|
|
|
|
import com.cloud.storage.Volume;
|
|
import com.cloud.storage.dao.VolumeDao;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.mockito.ArgumentMatchers.any;
|
|
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;
|
|
|
|
import java.util.ArrayList;
|
|
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;
|
|
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
|
|
import org.junit.After;
|
|
import org.junit.Assert;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.mockito.InjectMocks;
|
|
import org.mockito.Mock;
|
|
import org.mockito.Mockito;
|
|
import org.mockito.Spy;
|
|
import org.mockito.junit.MockitoJUnitRunner;
|
|
import org.powermock.core.classloader.annotations.PrepareForTest;
|
|
import org.springframework.test.util.ReflectionTestUtils;
|
|
|
|
import com.cloud.configuration.Resource;
|
|
import com.cloud.dc.DataCenter;
|
|
import com.cloud.dc.DataCenterVO;
|
|
import com.cloud.dc.dao.DataCenterDao;
|
|
import com.cloud.exception.InsufficientAddressCapacityException;
|
|
import com.cloud.exception.InsufficientCapacityException;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.exception.ResourceAllocationException;
|
|
import com.cloud.exception.ResourceUnavailableException;
|
|
import com.cloud.hypervisor.Hypervisor;
|
|
import com.cloud.network.NetworkModel;
|
|
import com.cloud.network.dao.NetworkDao;
|
|
import com.cloud.network.dao.NetworkVO;
|
|
import com.cloud.offering.ServiceOffering;
|
|
import com.cloud.service.ServiceOfferingVO;
|
|
import com.cloud.service.dao.ServiceOfferingDao;
|
|
import com.cloud.storage.DiskOfferingVO;
|
|
import com.cloud.storage.GuestOSVO;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.VolumeApiService;
|
|
import com.cloud.storage.VolumeVO;
|
|
import com.cloud.storage.dao.DiskOfferingDao;
|
|
import com.cloud.storage.dao.GuestOSDao;
|
|
import com.cloud.storage.dao.VMTemplateDao;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.user.AccountManager;
|
|
import com.cloud.user.AccountService;
|
|
import com.cloud.user.AccountVO;
|
|
import com.cloud.user.ResourceLimitService;
|
|
import com.cloud.user.UserVO;
|
|
import com.cloud.user.dao.AccountDao;
|
|
import com.cloud.uservm.UserVm;
|
|
import com.cloud.utils.db.EntityManager;
|
|
import com.cloud.vm.dao.NicDao;
|
|
import com.cloud.vm.dao.UserVmDao;
|
|
import com.cloud.vm.dao.UserVmDetailsDao;
|
|
|
|
@RunWith(MockitoJUnitRunner.class)
|
|
public class UserVmManagerImplTest {
|
|
|
|
@Spy
|
|
@InjectMocks
|
|
private UserVmManagerImpl userVmManagerImpl = new UserVmManagerImpl();
|
|
|
|
@Mock
|
|
private ServiceOfferingDao _serviceOfferingDao;
|
|
|
|
@Mock
|
|
private DiskOfferingDao diskOfferingDao;
|
|
|
|
@Mock
|
|
private DataCenterDao _dcDao;
|
|
@Mock
|
|
private DataCenterVO _dcMock;
|
|
|
|
@Mock
|
|
protected NicDao nicDao;
|
|
|
|
@Mock
|
|
private NetworkDao _networkDao;
|
|
|
|
@Mock
|
|
private NetworkOrchestrationService _networkMgr;
|
|
|
|
@Mock
|
|
private NetworkVO _networkMock;
|
|
|
|
@Mock
|
|
private GuestOSDao guestOSDao;
|
|
|
|
@Mock
|
|
private UserVmDao userVmDao;
|
|
|
|
@Mock
|
|
private UpdateVMCmd updateVmCommand;
|
|
|
|
@Mock
|
|
private AccountManager accountManager;
|
|
|
|
@Mock
|
|
private AccountService accountService;
|
|
|
|
@Mock
|
|
private EntityManager entityManager;
|
|
|
|
@Mock
|
|
private UserVmDetailsDao userVmDetailsDao;
|
|
|
|
@Mock
|
|
private UserVmVO userVmVoMock;
|
|
|
|
@Mock
|
|
private NetworkModel networkModel;
|
|
|
|
@Mock
|
|
private Account accountMock;
|
|
|
|
@Mock
|
|
private AccountVO callerAccount;
|
|
|
|
@Mock
|
|
private UserVO callerUser;
|
|
|
|
@Mock
|
|
private VMTemplateDao templateDao;
|
|
|
|
@Mock
|
|
private AccountDao accountDao;
|
|
|
|
@Mock
|
|
ResourceLimitService resourceLimitMgr;
|
|
|
|
@Mock
|
|
VolumeApiService volumeApiService;
|
|
|
|
@Mock
|
|
UserDataDao userDataDao;
|
|
|
|
@Mock
|
|
private VolumeVO volumeVOMock;
|
|
|
|
@Mock
|
|
private VolumeDao volumeDaoMock;
|
|
|
|
@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;
|
|
|
|
private Map<String, String> customParameters = new HashMap<>();
|
|
|
|
private DiskOfferingVO smallerDisdkOffering = prepareDiskOffering(5l * GiB_TO_BYTES, 1l, 1L, 2L);
|
|
private DiskOfferingVO largerDisdkOffering = prepareDiskOffering(10l * GiB_TO_BYTES, 2l, 10L, 20L);
|
|
|
|
@Before
|
|
public void beforeTest() {
|
|
|
|
Mockito.when(updateVmCommand.getId()).thenReturn(vmId);
|
|
|
|
when(_dcDao.findById(anyLong())).thenReturn(_dcMock);
|
|
|
|
Mockito.when(userVmDao.findById(vmId)).thenReturn(userVmVoMock);
|
|
|
|
Mockito.when(callerAccount.getType()).thenReturn(Account.Type.ADMIN);
|
|
CallContext.register(callerUser, callerAccount);
|
|
|
|
customParameters.put(VmDetailConstants.ROOT_DISK_SIZE, "123");
|
|
lenient().doNothing().when(resourceLimitMgr).incrementResourceCount(anyLong(), any(Resource.ResourceType.class));
|
|
lenient().doNothing().when(resourceLimitMgr).decrementResourceCount(anyLong(), any(Resource.ResourceType.class), anyLong());
|
|
}
|
|
|
|
@After
|
|
public void afterTest() {
|
|
CallContext.unregister();
|
|
}
|
|
|
|
@Test
|
|
public void validateGuestOsIdForUpdateVirtualMachineCommandTestOsTypeNull() {
|
|
Mockito.when(updateVmCommand.getOsTypeId()).thenReturn(null);
|
|
userVmManagerImpl.validateGuestOsIdForUpdateVirtualMachineCommand(updateVmCommand);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void validateGuestOsIdForUpdateVirtualMachineCommandTestOsTypeNotFound() {
|
|
Mockito.when(updateVmCommand.getOsTypeId()).thenReturn(1l);
|
|
|
|
userVmManagerImpl.validateGuestOsIdForUpdateVirtualMachineCommand(updateVmCommand);
|
|
}
|
|
|
|
@Test
|
|
public void validateGuestOsIdForUpdateVirtualMachineCommandTestOsTypeFound() {
|
|
Mockito.when(updateVmCommand.getOsTypeId()).thenReturn(1l);
|
|
Mockito.when(guestOSDao.findById(1l)).thenReturn(Mockito.mock(GuestOSVO.class));
|
|
|
|
userVmManagerImpl.validateGuestOsIdForUpdateVirtualMachineCommand(updateVmCommand);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void validateInputsAndPermissionForUpdateVirtualMachineCommandTestVmNotFound() {
|
|
Mockito.when(userVmDao.findById(vmId)).thenReturn(null);
|
|
|
|
userVmManagerImpl.validateInputsAndPermissionForUpdateVirtualMachineCommand(updateVmCommand);
|
|
}
|
|
|
|
private ServiceOfferingVO getSvcoffering(int ramSize) {
|
|
String name = "name";
|
|
String displayText = "displayText";
|
|
int cpu = 1;
|
|
int speed = 128;
|
|
|
|
boolean ha = false;
|
|
boolean useLocalStorage = false;
|
|
|
|
ServiceOfferingVO serviceOffering = new ServiceOfferingVO(name, cpu, ramSize, speed, null, null, ha, displayText, false, null,
|
|
false);
|
|
serviceOffering.setDiskOfferingId(1l);
|
|
return serviceOffering;
|
|
}
|
|
|
|
@Test
|
|
@PrepareForTest(CallContext.class)
|
|
public void validateInputsAndPermissionForUpdateVirtualMachineCommandTest() {
|
|
Mockito.doNothing().when(userVmManagerImpl).validateGuestOsIdForUpdateVirtualMachineCommand(updateVmCommand);
|
|
|
|
CallContext callContextMock = Mockito.mock(CallContext.class);
|
|
|
|
Mockito.lenient().doReturn(accountMock).when(callContextMock).getCallingAccount();
|
|
|
|
ServiceOffering offering = getSvcoffering(512);
|
|
Mockito.lenient().when(_serviceOfferingDao.findById(Mockito.anyLong(), Mockito.anyLong())).thenReturn((ServiceOfferingVO) offering);
|
|
Mockito.lenient().doNothing().when(accountManager).checkAccess(accountMock, null, true, userVmVoMock);
|
|
userVmManagerImpl.validateInputsAndPermissionForUpdateVirtualMachineCommand(updateVmCommand);
|
|
|
|
Mockito.verify(userVmManagerImpl).validateGuestOsIdForUpdateVirtualMachineCommand(updateVmCommand);
|
|
Mockito.verify(accountManager).checkAccess(callerAccount, null, true, userVmVoMock);
|
|
}
|
|
|
|
@Test
|
|
public void updateVirtualMachineTestDisplayChanged() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
configureDoNothingForMethodsThatWeDoNotWantToTest();
|
|
ServiceOffering offering = getSvcoffering(512);
|
|
Mockito.when(_serviceOfferingDao.findById(Mockito.anyLong(), Mockito.anyLong())).thenReturn((ServiceOfferingVO) offering);
|
|
Mockito.when(userVmVoMock.isDisplay()).thenReturn(true);
|
|
Mockito.doNothing().when(userVmManagerImpl).updateDisplayVmFlag(false, vmId, userVmVoMock);
|
|
Mockito.when(updateVmCommand.getUserdataId()).thenReturn(null);
|
|
userVmManagerImpl.updateVirtualMachine(updateVmCommand);
|
|
verifyMethodsThatAreAlwaysExecuted();
|
|
|
|
Mockito.verify(userVmManagerImpl).updateDisplayVmFlag(false, vmId, userVmVoMock);
|
|
Mockito.verify(userVmDetailsDao, Mockito.times(0)).removeDetail(anyLong(), anyString());
|
|
}
|
|
|
|
@Test
|
|
public void updateVirtualMachineTestCleanUpTrue() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
configureDoNothingForMethodsThatWeDoNotWantToTest();
|
|
ServiceOffering offering = getSvcoffering(512);
|
|
Mockito.when(_serviceOfferingDao.findById(Mockito.anyLong(), Mockito.anyLong())).thenReturn((ServiceOfferingVO) offering);
|
|
Mockito.when(updateVmCommand.isCleanupDetails()).thenReturn(true);
|
|
Mockito.lenient().doNothing().when(userVmManagerImpl).updateDisplayVmFlag(false, vmId, userVmVoMock);
|
|
|
|
Mockito.when(updateVmCommand.getUserdataId()).thenReturn(null);
|
|
|
|
prepareExistingDetails(vmId, "userdetail");
|
|
|
|
userVmManagerImpl.updateVirtualMachine(updateVmCommand);
|
|
verifyMethodsThatAreAlwaysExecuted();
|
|
Mockito.verify(userVmDetailsDao).removeDetail(vmId, "userdetail");
|
|
Mockito.verify(userVmDetailsDao, Mockito.times(0)).removeDetail(vmId, "systemdetail");
|
|
Mockito.verify(userVmManagerImpl, Mockito.times(0)).updateDisplayVmFlag(false, vmId, userVmVoMock);
|
|
}
|
|
|
|
@Test
|
|
public void updateVirtualMachineTestCleanUpTrueAndDetailEmpty() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
prepareAndExecuteMethodDealingWithDetails(true, true);
|
|
}
|
|
|
|
@Test
|
|
public void updateVirtualMachineTestCleanUpTrueAndDetailsNotEmpty() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
prepareAndExecuteMethodDealingWithDetails(true, false);
|
|
}
|
|
|
|
@Test
|
|
public void updateVirtualMachineTestCleanUpFalseAndDetailsNotEmpty() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
prepareAndExecuteMethodDealingWithDetails(false, true);
|
|
}
|
|
|
|
@Test
|
|
public void updateVirtualMachineTestCleanUpFalseAndDetailsEmpty() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
Mockito.when(accountDao.findById(Mockito.anyLong())).thenReturn(callerAccount);
|
|
prepareAndExecuteMethodDealingWithDetails(false, false);
|
|
}
|
|
|
|
private List<UserVmDetailVO> prepareExistingDetails(Long vmId, String... existingDetailKeys) {
|
|
List<UserVmDetailVO> existingDetails = new ArrayList<>();
|
|
for (String detail : existingDetailKeys) {
|
|
existingDetails.add(new UserVmDetailVO(vmId, detail, "foo", true));
|
|
}
|
|
existingDetails.add(new UserVmDetailVO(vmId, "systemdetail", "bar", false));
|
|
Mockito.when(userVmDetailsDao.listDetails(vmId)).thenReturn(existingDetails);
|
|
return existingDetails;
|
|
}
|
|
|
|
private void prepareAndExecuteMethodDealingWithDetails(boolean cleanUpDetails, boolean isDetailsEmpty) throws ResourceUnavailableException, InsufficientCapacityException {
|
|
configureDoNothingForMethodsThatWeDoNotWantToTest();
|
|
|
|
ServiceOffering offering = getSvcoffering(512);
|
|
Mockito.when(_serviceOfferingDao.findById(Mockito.anyLong(), Mockito.anyLong())).thenReturn((ServiceOfferingVO) offering);
|
|
Mockito.when(_serviceOfferingDao.findByIdIncludingRemoved(Mockito.anyLong(), Mockito.anyLong())).thenReturn((ServiceOfferingVO) offering);
|
|
ServiceOfferingVO currentServiceOffering = Mockito.mock(ServiceOfferingVO.class);
|
|
Mockito.lenient().when(currentServiceOffering.getCpu()).thenReturn(1);
|
|
Mockito.lenient().when(currentServiceOffering.getRamSize()).thenReturn(512);
|
|
|
|
List<NicVO> nics = new ArrayList<>();
|
|
NicVO nic1 = mock(NicVO.class);
|
|
NicVO nic2 = mock(NicVO.class);
|
|
nics.add(nic1);
|
|
nics.add(nic2);
|
|
when(this.nicDao.listByVmId(Mockito.anyLong())).thenReturn(nics);
|
|
when(_networkDao.findById(anyLong())).thenReturn(_networkMock);
|
|
lenient().doNothing().when(_networkMgr).saveExtraDhcpOptions(anyString(), anyLong(), anyMap());
|
|
HashMap<String, String> details = new HashMap<>();
|
|
if(!isDetailsEmpty) {
|
|
details.put("newdetail", "foo");
|
|
}
|
|
prepareExistingDetails(vmId, "existingdetail");
|
|
Mockito.when(updateVmCommand.getUserdataId()).thenReturn(null);
|
|
Mockito.when(updateVmCommand.getDetails()).thenReturn(details);
|
|
Mockito.when(updateVmCommand.isCleanupDetails()).thenReturn(cleanUpDetails);
|
|
configureDoNothingForDetailsMethod();
|
|
|
|
userVmManagerImpl.updateVirtualMachine(updateVmCommand);
|
|
verifyMethodsThatAreAlwaysExecuted();
|
|
|
|
Mockito.verify(userVmVoMock, Mockito.times(cleanUpDetails || isDetailsEmpty ? 0 : 1)).setDetails(details);
|
|
Mockito.verify(userVmDetailsDao, Mockito.times(cleanUpDetails ? 1 : 0)).removeDetail(vmId, "existingdetail");
|
|
Mockito.verify(userVmDetailsDao, Mockito.times(0)).removeDetail(vmId, "systemdetail");
|
|
Mockito.verify(userVmDao, Mockito.times(cleanUpDetails || isDetailsEmpty ? 0 : 1)).saveDetails(userVmVoMock);
|
|
Mockito.verify(userVmManagerImpl, Mockito.times(0)).updateDisplayVmFlag(false, vmId, userVmVoMock);
|
|
}
|
|
|
|
private void configureDoNothingForDetailsMethod() {
|
|
Mockito.lenient().doNothing().when(userVmManagerImpl).updateDisplayVmFlag(false, vmId, userVmVoMock);
|
|
Mockito.doNothing().when(userVmDetailsDao).removeDetail(anyLong(), anyString());
|
|
Mockito.doNothing().when(userVmDao).saveDetails(userVmVoMock);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private void verifyMethodsThatAreAlwaysExecuted() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
Mockito.verify(userVmManagerImpl).validateInputsAndPermissionForUpdateVirtualMachineCommand(updateVmCommand);
|
|
Mockito.verify(userVmManagerImpl).getSecurityGroupIdList(updateVmCommand);
|
|
|
|
Mockito.verify(userVmManagerImpl).updateVirtualMachine(nullable(Long.class), nullable(String.class), nullable(String.class), nullable(Boolean.class),
|
|
nullable(Boolean.class), nullable(Long.class),
|
|
nullable(String.class), nullable(Long.class), nullable(String.class), nullable(Boolean.class), nullable(HTTPMethod.class), nullable(String.class), nullable(String.class), nullable(String.class), nullable(List.class),
|
|
nullable(Map.class));
|
|
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private void configureDoNothingForMethodsThatWeDoNotWantToTest() throws ResourceUnavailableException, InsufficientCapacityException {
|
|
Mockito.doNothing().when(userVmManagerImpl).validateInputsAndPermissionForUpdateVirtualMachineCommand(updateVmCommand);
|
|
Mockito.doReturn(new ArrayList<Long>()).when(userVmManagerImpl).getSecurityGroupIdList(updateVmCommand);
|
|
Mockito.lenient().doReturn(Mockito.mock(UserVm.class)).when(userVmManagerImpl).updateVirtualMachine(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
|
|
Mockito.anyBoolean(), Mockito.anyLong(),
|
|
Mockito.anyString(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyBoolean(), Mockito.any(HTTPMethod.class), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyListOf(Long.class),
|
|
Mockito.anyMap());
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressValid() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(0, "01:23:45:67:89:ab", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressNull() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, null, "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressBlank() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, " ", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressEmpty() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, "", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressNotValidOption1() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, "abcdef:gh:ij:kl", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressNotValidOption2() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, "01:23:45:67:89:", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressNotValidOption3() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, "01:23:45:67:89:az", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
@Test
|
|
public void validateOrReplaceMacAddressTestMacAddressNotValidOption4() throws InsufficientAddressCapacityException {
|
|
configureValidateOrReplaceMacAddressTest(1, "@1:23:45:67:89:ab", "01:23:45:67:89:ab");
|
|
}
|
|
|
|
private void configureValidateOrReplaceMacAddressTest(int times, String macAddress, String expectedMacAddress) throws InsufficientAddressCapacityException {
|
|
Mockito.when(networkModel.getNextAvailableMacAddressInNetwork(Mockito.anyLong())).thenReturn(expectedMacAddress);
|
|
|
|
String returnedMacAddress = userVmManagerImpl.validateOrReplaceMacAddress(macAddress, 1l);
|
|
|
|
Mockito.verify(networkModel, Mockito.times(times)).getNextAvailableMacAddressInNetwork(Mockito.anyLong());
|
|
assertEquals(expectedMacAddress, returnedMacAddress);
|
|
}
|
|
|
|
@Test
|
|
public void testValidatekeyValuePair() throws Exception {
|
|
assertTrue(userVmManagerImpl.isValidKeyValuePair("is-a-template=true\nHVM-boot-policy=\nPV-bootloader=pygrub\nPV-args=hvc0"));
|
|
assertTrue(userVmManagerImpl.isValidKeyValuePair("is-a-template=true HVM-boot-policy= PV-bootloader=pygrub PV-args=hvc0"));
|
|
assertTrue(userVmManagerImpl.isValidKeyValuePair("nvp.vm-uuid=34b3d5ea-1c25-4bb0-9250-8dc3388bfa9b"));
|
|
assertFalse(userVmManagerImpl.isValidKeyValuePair("key"));
|
|
//key-1=value1, param:key-2=value2, my.config.v0=False"
|
|
assertTrue(userVmManagerImpl.isValidKeyValuePair("key-1=value1"));
|
|
assertTrue(userVmManagerImpl.isValidKeyValuePair("param:key-2=value2"));
|
|
assertTrue(userVmManagerImpl.isValidKeyValuePair("my.config.v0=False"));
|
|
}
|
|
|
|
@Test
|
|
public void configureCustomRootDiskSizeTest() {
|
|
String vmDetailsRootDiskSize = "123";
|
|
Map<String, String> customParameters = new HashMap<>();
|
|
customParameters.put(VmDetailConstants.ROOT_DISK_SIZE, vmDetailsRootDiskSize);
|
|
long expectedRootDiskSize = 123l * GiB_TO_BYTES;
|
|
long offeringRootDiskSize = 0l;
|
|
prepareAndRunConfigureCustomRootDiskSizeTest(customParameters, expectedRootDiskSize, 1, offeringRootDiskSize);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void configureCustomRootDiskSizeTestExpectExceptionZero() {
|
|
String vmDetailsRootDiskSize = "0";
|
|
Map<String, String> customParameters = new HashMap<>();
|
|
customParameters.put(VmDetailConstants.ROOT_DISK_SIZE, vmDetailsRootDiskSize);
|
|
long expectedRootDiskSize = 0l;
|
|
long offeringRootDiskSize = 0l;
|
|
prepareAndRunConfigureCustomRootDiskSizeTest(customParameters, expectedRootDiskSize, 1, offeringRootDiskSize);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void configureCustomRootDiskSizeTestExpectExceptionNegativeNum() {
|
|
String vmDetailsRootDiskSize = "-123";
|
|
Map<String, String> customParameters = new HashMap<>();
|
|
customParameters.put(VmDetailConstants.ROOT_DISK_SIZE, vmDetailsRootDiskSize);
|
|
long expectedRootDiskSize = -123l * GiB_TO_BYTES;
|
|
long offeringRootDiskSize = 0l;
|
|
prepareAndRunConfigureCustomRootDiskSizeTest(customParameters, expectedRootDiskSize, 1, offeringRootDiskSize);
|
|
}
|
|
|
|
@Test
|
|
public void configureCustomRootDiskSizeTestEmptyParameters() {
|
|
Map<String, String> customParameters = new HashMap<>();
|
|
long expectedRootDiskSize = 99l * GiB_TO_BYTES;
|
|
long offeringRootDiskSize = 0l;
|
|
prepareAndRunConfigureCustomRootDiskSizeTest(customParameters, expectedRootDiskSize, 1, offeringRootDiskSize);
|
|
}
|
|
|
|
@Test
|
|
public void configureCustomRootDiskSizeTestEmptyParametersAndOfferingRootSize() {
|
|
Map<String, String> customParameters = new HashMap<>();
|
|
long expectedRootDiskSize = 10l * GiB_TO_BYTES;
|
|
long offeringRootDiskSize = 10l * GiB_TO_BYTES;;
|
|
|
|
prepareAndRunConfigureCustomRootDiskSizeTest(customParameters, expectedRootDiskSize, 1, offeringRootDiskSize);
|
|
}
|
|
|
|
private void prepareAndRunConfigureCustomRootDiskSizeTest(Map<String, String> customParameters, long expectedRootDiskSize, int timesVerifyIfHypervisorSupports, Long offeringRootDiskSize) {
|
|
VMTemplateVO template = Mockito.mock(VMTemplateVO.class);
|
|
Mockito.when(template.getId()).thenReturn(1l);
|
|
Mockito.when(template.getSize()).thenReturn(99L * GiB_TO_BYTES);
|
|
Mockito.when(templateDao.findById(Mockito.anyLong())).thenReturn(template);
|
|
|
|
DiskOfferingVO diskfferingVo = Mockito.mock(DiskOfferingVO.class);
|
|
|
|
Mockito.when(diskfferingVo.getDiskSize()).thenReturn(offeringRootDiskSize);
|
|
|
|
Mockito.when(volumeApiService.validateVolumeSizeInBytes(Mockito.anyLong())).thenReturn(true);
|
|
long rootDiskSize = userVmManagerImpl.configureCustomRootDiskSize(customParameters, template, Hypervisor.HypervisorType.KVM, diskfferingVo);
|
|
|
|
Assert.assertEquals(expectedRootDiskSize, rootDiskSize);
|
|
Mockito.verify(userVmManagerImpl, Mockito.times(timesVerifyIfHypervisorSupports)).verifyIfHypervisorSupportsRootdiskSizeOverride(Mockito.any());
|
|
}
|
|
|
|
@Test
|
|
public void verifyIfHypervisorSupportRootdiskSizeOverrideTest() {
|
|
Hypervisor.HypervisorType[] hypervisorTypeArray = Hypervisor.HypervisorType.values();
|
|
int exceptionCounter = 0;
|
|
int expectedExceptionCounter = hypervisorTypeArray.length - 4;
|
|
|
|
for(int i = 0; i < hypervisorTypeArray.length; i++) {
|
|
if (Hypervisor.HypervisorType.KVM == hypervisorTypeArray[i]
|
|
|| Hypervisor.HypervisorType.XenServer == hypervisorTypeArray[i]
|
|
|| Hypervisor.HypervisorType.VMware == hypervisorTypeArray[i]
|
|
|| Hypervisor.HypervisorType.Simulator == hypervisorTypeArray[i]) {
|
|
userVmManagerImpl.verifyIfHypervisorSupportsRootdiskSizeOverride(hypervisorTypeArray[i]);
|
|
} else {
|
|
try {
|
|
userVmManagerImpl.verifyIfHypervisorSupportsRootdiskSizeOverride(hypervisorTypeArray[i]);
|
|
} catch (InvalidParameterValueException e) {
|
|
exceptionCounter ++;
|
|
}
|
|
}
|
|
}
|
|
|
|
Assert.assertEquals(expectedExceptionCounter, exceptionCounter);
|
|
}
|
|
|
|
@Test (expected = InvalidParameterValueException.class)
|
|
public void prepareResizeVolumeCmdTestRootVolumeNull() {
|
|
DiskOfferingVO newRootDiskOffering = Mockito.mock(DiskOfferingVO.class);
|
|
DiskOfferingVO currentRootDiskOffering = Mockito.mock(DiskOfferingVO.class);
|
|
userVmManagerImpl.prepareResizeVolumeCmd(null, currentRootDiskOffering, newRootDiskOffering);
|
|
}
|
|
|
|
@Test (expected = InvalidParameterValueException.class)
|
|
public void prepareResizeVolumeCmdTestCurrentRootDiskOffering() {
|
|
DiskOfferingVO newRootDiskOffering = Mockito.mock(DiskOfferingVO.class);
|
|
VolumeVO rootVolumeOfVm = Mockito.mock(VolumeVO.class);
|
|
userVmManagerImpl.prepareResizeVolumeCmd(rootVolumeOfVm, null, newRootDiskOffering);
|
|
}
|
|
|
|
@Test (expected = InvalidParameterValueException.class)
|
|
public void prepareResizeVolumeCmdTestNewRootDiskOffering() {
|
|
VolumeVO rootVolumeOfVm = Mockito.mock(VolumeVO.class);
|
|
DiskOfferingVO currentRootDiskOffering = Mockito.mock(DiskOfferingVO.class);
|
|
userVmManagerImpl.prepareResizeVolumeCmd(rootVolumeOfVm, currentRootDiskOffering, null);
|
|
}
|
|
|
|
@Test
|
|
public void prepareResizeVolumeCmdTestNewOfferingLarger() {
|
|
prepareAndRunResizeVolumeTest(2L, 10L, 20L, smallerDisdkOffering, largerDisdkOffering);
|
|
}
|
|
|
|
@Test
|
|
public void prepareResizeVolumeCmdTestSameOfferingSize() {
|
|
prepareAndRunResizeVolumeTest(null, 1L, 2L, smallerDisdkOffering, smallerDisdkOffering);
|
|
}
|
|
|
|
@Test
|
|
public void prepareResizeVolumeCmdTestOfferingRootSizeZero() {
|
|
DiskOfferingVO rootSizeZero = prepareDiskOffering(0l, 3l, 100L, 200L);
|
|
prepareAndRunResizeVolumeTest(null, 100L, 200L, smallerDisdkOffering, rootSizeZero);
|
|
}
|
|
|
|
@Test (expected = InvalidParameterValueException.class)
|
|
public void prepareResizeVolumeCmdTestNewOfferingSmaller() {
|
|
prepareAndRunResizeVolumeTest(2L, 10L, 20L, largerDisdkOffering, smallerDisdkOffering);
|
|
}
|
|
|
|
@Test
|
|
public void validateDiskOfferingCheckForEncryption1Test() {
|
|
ServiceOfferingVO currentOffering = prepareOfferingsForEncryptionValidation(1L, true);
|
|
ServiceOfferingVO newOffering = prepareOfferingsForEncryptionValidation(2L, true);
|
|
userVmManagerImpl.validateDiskOfferingChecks(currentOffering, newOffering);
|
|
}
|
|
|
|
@Test
|
|
public void validateDiskOfferingCheckForEncryption2Test() {
|
|
ServiceOfferingVO currentOffering = prepareOfferingsForEncryptionValidation(1L, false);
|
|
ServiceOfferingVO newOffering = prepareOfferingsForEncryptionValidation(2L, false);
|
|
userVmManagerImpl.validateDiskOfferingChecks(currentOffering, newOffering);
|
|
}
|
|
|
|
@Test (expected = InvalidParameterValueException.class)
|
|
public void validateDiskOfferingCheckForEncryptionFail1Test() {
|
|
ServiceOfferingVO currentOffering = prepareOfferingsForEncryptionValidation(1L, false);
|
|
ServiceOfferingVO newOffering = prepareOfferingsForEncryptionValidation(2L, true);
|
|
userVmManagerImpl.validateDiskOfferingChecks(currentOffering, newOffering);
|
|
}
|
|
|
|
@Test (expected = InvalidParameterValueException.class)
|
|
public void validateDiskOfferingCheckForEncryptionFail2Test() {
|
|
ServiceOfferingVO currentOffering = prepareOfferingsForEncryptionValidation(1L, true);
|
|
ServiceOfferingVO newOffering = prepareOfferingsForEncryptionValidation(2L, false);
|
|
userVmManagerImpl.validateDiskOfferingChecks(currentOffering, newOffering);
|
|
}
|
|
|
|
private void prepareAndRunResizeVolumeTest(Long expectedOfferingId, long expectedMinIops, long expectedMaxIops, DiskOfferingVO currentRootDiskOffering, DiskOfferingVO newRootDiskOffering) {
|
|
long rootVolumeId = 1l;
|
|
VolumeVO rootVolumeOfVm = Mockito.mock(VolumeVO.class);
|
|
Mockito.when(rootVolumeOfVm.getId()).thenReturn(rootVolumeId);
|
|
|
|
ResizeVolumeCmd resizeVolumeCmd = userVmManagerImpl.prepareResizeVolumeCmd(rootVolumeOfVm, currentRootDiskOffering, newRootDiskOffering);
|
|
|
|
Assert.assertEquals(rootVolumeId, resizeVolumeCmd.getId().longValue());
|
|
Assert.assertEquals(expectedOfferingId, resizeVolumeCmd.getNewDiskOfferingId());
|
|
Assert.assertEquals(expectedMinIops, resizeVolumeCmd.getMinIops().longValue());
|
|
Assert.assertEquals(expectedMaxIops, resizeVolumeCmd.getMaxIops().longValue());
|
|
}
|
|
|
|
private DiskOfferingVO prepareDiskOffering(long rootSize, long diskOfferingId, long offeringMinIops, long offeringMaxIops) {
|
|
DiskOfferingVO newRootDiskOffering = Mockito.mock(DiskOfferingVO.class);
|
|
Mockito.when(newRootDiskOffering.getDiskSize()).thenReturn(rootSize);
|
|
Mockito.when(newRootDiskOffering.getId()).thenReturn(diskOfferingId);
|
|
Mockito.when(newRootDiskOffering.getMinIops()).thenReturn(offeringMinIops);
|
|
Mockito.when(newRootDiskOffering.getMaxIops()).thenReturn(offeringMaxIops);
|
|
Mockito.when(newRootDiskOffering.getName()).thenReturn("OfferingName");
|
|
return newRootDiskOffering;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|