mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
b9ed42bd29
* Primary Storage count for an account does not decrease when a Data Disk is deleted When a data disk is created and not attached in a running VM, the "deleteVolume" will not decrement the count for used primary storage in the VMs accounting information. The property that is not being decremented is called "primarystoragetotal"; this information can be retrieved via "listAccounts" API method. Steps to reproduce this issue: 1 - Create an account, deploy a VM in it 2 - Check the primary storage count for the account with listAccounts API 3 - Create a data disk 4 - Check the primary storage count for the account with listAccounts API 5 - Delete the Data disk 6 - Check the primary storage count for the account with listAccounts API - It is the same as before deleting the data disk (it should not be the same as the value in step 2!) * formatting and cleanups * fix imports that were wrongly changed during rebase
882 lines
46 KiB
Java
882 lines
46 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.storage;
|
|
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.mockito.Matchers.any;
|
|
import static org.mockito.Matchers.anyLong;
|
|
import static org.mockito.Matchers.anyString;
|
|
import static org.mockito.Matchers.eq;
|
|
import static org.mockito.Mockito.doNothing;
|
|
import static org.mockito.Mockito.doThrow;
|
|
import static org.mockito.Mockito.times;
|
|
import static org.mockito.Mockito.verify;
|
|
import static org.mockito.Mockito.when;
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.ExecutionException;
|
|
|
|
import org.apache.cloudstack.acl.ControlledEntity;
|
|
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
|
|
import org.apache.cloudstack.api.command.user.volume.CreateVolumeCmd;
|
|
import org.apache.cloudstack.api.command.user.volume.DetachVolumeCmd;
|
|
import org.apache.cloudstack.context.CallContext;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotInfo;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.VolumeDataFactory;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.VolumeService;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.VolumeService.VolumeApiResult;
|
|
import org.apache.cloudstack.framework.async.AsyncCallFuture;
|
|
import org.apache.cloudstack.framework.jobs.AsyncJobExecutionContext;
|
|
import org.apache.cloudstack.framework.jobs.AsyncJobManager;
|
|
import org.apache.cloudstack.framework.jobs.dao.AsyncJobJoinMapDao;
|
|
import org.apache.cloudstack.framework.jobs.impl.AsyncJobVO;
|
|
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
|
|
import org.apache.cloudstack.storage.datastore.db.VolumeDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.VolumeDataStoreVO;
|
|
import org.junit.After;
|
|
import org.junit.Assert;
|
|
import org.junit.Before;
|
|
import org.junit.Rule;
|
|
import org.junit.Test;
|
|
import org.junit.rules.ExpectedException;
|
|
import org.junit.runner.RunWith;
|
|
import org.mockito.InjectMocks;
|
|
import org.mockito.Mock;
|
|
import org.mockito.Mockito;
|
|
import org.mockito.Spy;
|
|
import org.mockito.runners.MockitoJUnitRunner;
|
|
|
|
import com.cloud.configuration.Resource;
|
|
import com.cloud.configuration.Resource.ResourceType;
|
|
import com.cloud.dc.DataCenterVO;
|
|
import com.cloud.dc.dao.DataCenterDao;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.exception.ResourceAllocationException;
|
|
import com.cloud.host.dao.HostDao;
|
|
import com.cloud.hypervisor.Hypervisor.HypervisorType;
|
|
import com.cloud.org.Grouping;
|
|
import com.cloud.storage.dao.VolumeDao;
|
|
import com.cloud.storage.snapshot.SnapshotManager;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.user.AccountManager;
|
|
import com.cloud.user.AccountVO;
|
|
import com.cloud.user.ResourceLimitService;
|
|
import com.cloud.user.User;
|
|
import com.cloud.user.UserVO;
|
|
import com.cloud.user.dao.AccountDao;
|
|
import com.cloud.utils.db.TransactionLegacy;
|
|
import com.cloud.utils.fsm.NoTransitionException;
|
|
import com.cloud.vm.UserVmManager;
|
|
import com.cloud.vm.UserVmVO;
|
|
import com.cloud.vm.VirtualMachine;
|
|
import com.cloud.vm.VirtualMachine.State;
|
|
import com.cloud.vm.dao.UserVmDao;
|
|
import com.cloud.vm.dao.VMInstanceDao;
|
|
import com.cloud.vm.snapshot.VMSnapshotVO;
|
|
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
|
|
|
|
@RunWith(MockitoJUnitRunner.class)
|
|
public class VolumeApiServiceImplTest {
|
|
|
|
@Spy
|
|
@InjectMocks
|
|
private VolumeApiServiceImpl volumeApiServiceImpl = new VolumeApiServiceImpl();
|
|
@Mock
|
|
private VolumeDao volumeDaoMock;
|
|
@Mock
|
|
private SnapshotManager snapshotManagerMock;
|
|
@Mock
|
|
private VolumeDataStoreDao volumeDataStoreDaoMock;
|
|
@Mock
|
|
private AccountManager accountManagerMock;
|
|
@Mock
|
|
private VolumeService volumeServiceMock;
|
|
@Mock
|
|
private ResourceLimitService resourceLimitServiceMock;
|
|
@Mock
|
|
private VolumeDataFactory volumeDataFactoryMock;
|
|
|
|
@Mock
|
|
private UserVmDao userVmDaoMock;
|
|
@Mock
|
|
private PrimaryDataStoreDao primaryDataStoreDaoMock;
|
|
@Mock
|
|
private VMSnapshotDao vmSnapshotDaoMock;
|
|
@Mock
|
|
private AsyncJobManager asyncJobManagerMock;
|
|
@Mock
|
|
private AsyncJobJoinMapDao asyncJobJoinMapDaoMock;
|
|
@Mock
|
|
private UserVmManager userVmManagerMock;
|
|
@Mock
|
|
private VMInstanceDao vMInstanceDaoMock;
|
|
@Mock
|
|
private SnapshotInfo snapshotInfoMock;
|
|
@Mock
|
|
private CreateVolumeCmd createVolumeCmdMock;
|
|
@Mock
|
|
private DataCenterDao dataCenterDaoMock;
|
|
@Mock
|
|
private AccountDao accountDaoMock;
|
|
@Mock
|
|
private HostDao hostdaoMock;
|
|
|
|
DetachVolumeCmd detachCmd = new DetachVolumeCmd();
|
|
Class<?> _detachCmdClass = detachCmd.getClass();
|
|
|
|
@Mock
|
|
private Account accountMock;
|
|
@Mock
|
|
private VolumeVO volumeVoMock;
|
|
@Mock
|
|
private VolumeDataStoreVO volumeDataStoreVoMock;
|
|
@Mock
|
|
private AsyncCallFuture<VolumeApiResult> asyncCallFutureVolumeapiResultMock;
|
|
@Mock
|
|
private VolumeInfo volumeInfoMock;
|
|
|
|
private long accountMockId = 456l;
|
|
private long volumeMockId = 12313l;
|
|
private long vmInstanceMockId = 1123l;
|
|
private long volumeSizeMock = 456789921939l;
|
|
|
|
@Before
|
|
public void setup() throws Exception {
|
|
Mockito.doReturn(volumeMockId).when(volumeDataStoreVoMock).getVolumeId();
|
|
Mockito.doReturn(volumeMockId).when(volumeVoMock).getId();
|
|
Mockito.doReturn(accountMockId).when(accountMock).getId();
|
|
Mockito.doReturn(volumeSizeMock).when(volumeVoMock).getSize();
|
|
Mockito.doReturn(Mockito.mock(VolumeApiResult.class)).when(asyncCallFutureVolumeapiResultMock).get();
|
|
|
|
// mock caller context
|
|
AccountVO account = new AccountVO("admin", 1L, "networkDomain", Account.ACCOUNT_TYPE_NORMAL, "uuid");
|
|
UserVO user = new UserVO(1, "testuser", "password", "firstname", "lastName", "email", "timezone", UUID.randomUUID().toString(), User.Source.UNKNOWN);
|
|
CallContext.register(user, account);
|
|
// mock async context
|
|
AsyncJobExecutionContext context = new AsyncJobExecutionContext();
|
|
AsyncJobExecutionContext.init(volumeApiServiceImpl._jobMgr, asyncJobJoinMapDaoMock);
|
|
AsyncJobVO job = new AsyncJobVO();
|
|
context.setJob(job);
|
|
AsyncJobExecutionContext.setCurrentExecutionContext(context);
|
|
|
|
TransactionLegacy txn = TransactionLegacy.open("runVolumeDaoImplTest");
|
|
try {
|
|
// volume of running vm id=1
|
|
VolumeVO volumeOfRunningVm = new VolumeVO("root", 1L, 1L, 1L, 1L, 1L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
when(volumeApiServiceImpl._volsDao.findById(1L)).thenReturn(volumeOfRunningVm);
|
|
|
|
UserVmVO runningVm = new UserVmVO(1L, "vm", "vm", 1, HypervisorType.XenServer, 1L, false, false, 1L, 1L, 1, 1L, null, "vm", null);
|
|
runningVm.setState(State.Running);
|
|
runningVm.setDataCenterId(1L);
|
|
when(volumeApiServiceImpl._userVmDao.findById(1L)).thenReturn(runningVm);
|
|
|
|
// volume of stopped vm id=2
|
|
VolumeVO volumeOfStoppedVm = new VolumeVO("root", 1L, 1L, 1L, 1L, 2L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
volumeOfStoppedVm.setPoolId(1L);
|
|
when(volumeApiServiceImpl._volsDao.findById(2L)).thenReturn(volumeOfStoppedVm);
|
|
|
|
UserVmVO stoppedVm = new UserVmVO(2L, "vm", "vm", 1, HypervisorType.XenServer, 1L, false, false, 1L, 1L, 1, 1L, null, "vm", null);
|
|
stoppedVm.setState(State.Stopped);
|
|
stoppedVm.setDataCenterId(1L);
|
|
when(volumeApiServiceImpl._userVmDao.findById(2L)).thenReturn(stoppedVm);
|
|
|
|
// volume of hyperV vm id=3
|
|
UserVmVO hyperVVm = new UserVmVO(3L, "vm", "vm", 1, HypervisorType.Hyperv, 1L, false, false, 1L, 1L, 1, 1L, null, "vm", null);
|
|
hyperVVm.setState(State.Stopped);
|
|
hyperVVm.setDataCenterId(1L);
|
|
when(volumeApiServiceImpl._userVmDao.findById(3L)).thenReturn(hyperVVm);
|
|
|
|
VolumeVO volumeOfStoppeHyperVVm = new VolumeVO("root", 1L, 1L, 1L, 1L, 3L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
volumeOfStoppeHyperVVm.setPoolId(1L);
|
|
when(volumeApiServiceImpl._volsDao.findById(3L)).thenReturn(volumeOfStoppeHyperVVm);
|
|
|
|
StoragePoolVO unmanagedPool = new StoragePoolVO();
|
|
|
|
when(volumeApiServiceImpl._storagePoolDao.findById(1L)).thenReturn(unmanagedPool);
|
|
|
|
// volume of managed pool id=4
|
|
StoragePoolVO managedPool = new StoragePoolVO();
|
|
managedPool.setManaged(true);
|
|
when(volumeApiServiceImpl._storagePoolDao.findById(2L)).thenReturn(managedPool);
|
|
VolumeVO managedPoolVolume = new VolumeVO("root", 1L, 1L, 1L, 1L, 2L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
managedPoolVolume.setPoolId(2L);
|
|
when(volumeApiServiceImpl._volsDao.findById(4L)).thenReturn(managedPoolVolume);
|
|
|
|
// non-root non-datadisk volume
|
|
VolumeInfo volumeWithIncorrectVolumeType = Mockito.mock(VolumeInfo.class);
|
|
when(volumeWithIncorrectVolumeType.getId()).thenReturn(5L);
|
|
when(volumeWithIncorrectVolumeType.getVolumeType()).thenReturn(Volume.Type.ISO);
|
|
when(volumeApiServiceImpl.volFactory.getVolume(5L)).thenReturn(volumeWithIncorrectVolumeType);
|
|
|
|
// correct root volume
|
|
VolumeInfo correctRootVolume = Mockito.mock(VolumeInfo.class);
|
|
when(correctRootVolume.getId()).thenReturn(6L);
|
|
when(correctRootVolume.getDataCenterId()).thenReturn(1L);
|
|
when(correctRootVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
|
|
when(correctRootVolume.getInstanceId()).thenReturn(null);
|
|
when(correctRootVolume.getState()).thenReturn(Volume.State.Ready);
|
|
when(correctRootVolume.getTemplateId()).thenReturn(null);
|
|
when(correctRootVolume.getPoolId()).thenReturn(1L);
|
|
when(volumeApiServiceImpl.volFactory.getVolume(6L)).thenReturn(correctRootVolume);
|
|
|
|
VolumeVO correctRootVolumeVO = new VolumeVO("root", 1L, 1L, 1L, 1L, 2L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
when(volumeApiServiceImpl._volsDao.findById(6L)).thenReturn(correctRootVolumeVO);
|
|
|
|
// managed root volume
|
|
VolumeInfo managedVolume = Mockito.mock(VolumeInfo.class);
|
|
when(managedVolume.getId()).thenReturn(7L);
|
|
when(managedVolume.getDataCenterId()).thenReturn(1L);
|
|
when(managedVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
|
|
when(managedVolume.getInstanceId()).thenReturn(null);
|
|
when(managedVolume.getPoolId()).thenReturn(2L);
|
|
when(volumeApiServiceImpl.volFactory.getVolume(7L)).thenReturn(managedVolume);
|
|
|
|
VolumeVO managedVolume1 = new VolumeVO("root", 1L, 1L, 1L, 1L, 2L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
managedVolume1.setPoolId(2L);
|
|
managedVolume1.setDataCenterId(1L);
|
|
when(volumeApiServiceImpl._volsDao.findById(7L)).thenReturn(managedVolume1);
|
|
|
|
// vm having root volume
|
|
UserVmVO vmHavingRootVolume = new UserVmVO(4L, "vm", "vm", 1, HypervisorType.XenServer, 1L, false, false, 1L, 1L, 1, 1L, null, "vm", null);
|
|
vmHavingRootVolume.setState(State.Stopped);
|
|
vmHavingRootVolume.setDataCenterId(1L);
|
|
when(volumeApiServiceImpl._userVmDao.findById(4L)).thenReturn(vmHavingRootVolume);
|
|
List<VolumeVO> vols = new ArrayList<VolumeVO>();
|
|
vols.add(new VolumeVO());
|
|
when(volumeApiServiceImpl._volsDao.findByInstanceAndDeviceId(4L, 0L)).thenReturn(vols);
|
|
|
|
// volume in uploaded state
|
|
VolumeInfo uploadedVolume = Mockito.mock(VolumeInfo.class);
|
|
when(uploadedVolume.getId()).thenReturn(8L);
|
|
when(uploadedVolume.getDataCenterId()).thenReturn(1L);
|
|
when(uploadedVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
|
|
when(uploadedVolume.getInstanceId()).thenReturn(null);
|
|
when(uploadedVolume.getPoolId()).thenReturn(1L);
|
|
when(uploadedVolume.getState()).thenReturn(Volume.State.Uploaded);
|
|
when(volumeApiServiceImpl.volFactory.getVolume(8L)).thenReturn(uploadedVolume);
|
|
|
|
VolumeVO upVolume = new VolumeVO("root", 1L, 1L, 1L, 1L, 2L, "root", "root", Storage.ProvisioningType.THIN, 1, null, null, "root", Volume.Type.ROOT);
|
|
upVolume.setPoolId(1L);
|
|
upVolume.setDataCenterId(1L);
|
|
upVolume.setState(Volume.State.Uploaded);
|
|
when(volumeApiServiceImpl._volsDao.findById(8L)).thenReturn(upVolume);
|
|
|
|
// helper dao methods mock
|
|
when(volumeApiServiceImpl._vmSnapshotDao.findByVm(any(Long.class))).thenReturn(new ArrayList<VMSnapshotVO>());
|
|
when(volumeApiServiceImpl._vmInstanceDao.findById(any(Long.class))).thenReturn(stoppedVm);
|
|
|
|
DataCenterVO enabledZone = Mockito.mock(DataCenterVO.class);
|
|
when(enabledZone.getAllocationState()).thenReturn(Grouping.AllocationState.Enabled);
|
|
|
|
when(volumeApiServiceImpl._dcDao.findById(anyLong())).thenReturn(enabledZone);
|
|
|
|
} finally {
|
|
txn.close("runVolumeDaoImplTest");
|
|
}
|
|
|
|
// helper methods mock
|
|
doNothing().when(volumeApiServiceImpl._accountMgr).checkAccess(any(Account.class), any(AccessType.class), any(Boolean.class), any(ControlledEntity.class));
|
|
doNothing().when(volumeApiServiceImpl._jobMgr).updateAsyncJobAttachment(any(Long.class), any(String.class), any(Long.class));
|
|
when(volumeApiServiceImpl._jobMgr.submitAsyncJob(any(AsyncJobVO.class), any(String.class), any(Long.class))).thenReturn(1L);
|
|
}
|
|
|
|
/**
|
|
* TESTS FOR DETACH ROOT VOLUME, COUNT=4
|
|
* @throws Exception
|
|
*/
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void testDetachVolumeFromRunningVm() throws NoSuchFieldException, IllegalAccessException {
|
|
Field dedicateIdField = _detachCmdClass.getDeclaredField("id");
|
|
dedicateIdField.setAccessible(true);
|
|
dedicateIdField.set(detachCmd, 1L);
|
|
volumeApiServiceImpl.detachVolumeFromVM(detachCmd);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void testDetachVolumeFromStoppedHyperVVm() throws NoSuchFieldException, IllegalAccessException {
|
|
Field dedicateIdField = _detachCmdClass.getDeclaredField("id");
|
|
dedicateIdField.setAccessible(true);
|
|
dedicateIdField.set(detachCmd, 3L);
|
|
volumeApiServiceImpl.detachVolumeFromVM(detachCmd);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void testDetachVolumeOfManagedDataStore() throws NoSuchFieldException, IllegalAccessException {
|
|
Field dedicateIdField = _detachCmdClass.getDeclaredField("id");
|
|
dedicateIdField.setAccessible(true);
|
|
dedicateIdField.set(detachCmd, 4L);
|
|
volumeApiServiceImpl.detachVolumeFromVM(detachCmd);
|
|
}
|
|
|
|
@Rule
|
|
public ExpectedException thrown = ExpectedException.none();
|
|
|
|
@Test
|
|
public void testDetachVolumeFromStoppedXenVm() throws NoSuchFieldException, IllegalAccessException {
|
|
thrown.expect(NullPointerException.class);
|
|
Field dedicateIdField = _detachCmdClass.getDeclaredField("id");
|
|
dedicateIdField.setAccessible(true);
|
|
dedicateIdField.set(detachCmd, 2L);
|
|
volumeApiServiceImpl.detachVolumeFromVM(detachCmd);
|
|
}
|
|
|
|
/**
|
|
* TESTS FOR ATTACH ROOT VOLUME, COUNT=7
|
|
*/
|
|
|
|
// Negative test - try to attach non-root non-datadisk volume
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void attachIncorrectDiskType() throws NoSuchFieldException, IllegalAccessException {
|
|
volumeApiServiceImpl.attachVolumeToVM(1L, 5L, 0L);
|
|
}
|
|
|
|
// Negative test - attach root volume to running vm
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void attachRootDiskToRunningVm() throws NoSuchFieldException, IllegalAccessException {
|
|
volumeApiServiceImpl.attachVolumeToVM(1L, 6L, 0L);
|
|
}
|
|
|
|
// Negative test - attach root volume to non-xen vm
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void attachRootDiskToHyperVm() throws NoSuchFieldException, IllegalAccessException {
|
|
volumeApiServiceImpl.attachVolumeToVM(3L, 6L, 0L);
|
|
}
|
|
|
|
// Negative test - attach root volume from the managed data store
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void attachRootDiskOfManagedDataStore() throws NoSuchFieldException, IllegalAccessException {
|
|
volumeApiServiceImpl.attachVolumeToVM(2L, 7L, 0L);
|
|
}
|
|
|
|
// Negative test - root volume can't be attached to the vm already having a root volume attached
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void attachRootDiskToVmHavingRootDisk() throws NoSuchFieldException, IllegalAccessException {
|
|
volumeApiServiceImpl.attachVolumeToVM(4L, 6L, 0L);
|
|
}
|
|
|
|
// Negative test - root volume in uploaded state can't be attached
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void attachRootInUploadedState() throws NoSuchFieldException, IllegalAccessException {
|
|
volumeApiServiceImpl.attachVolumeToVM(2L, 8L, 0L);
|
|
}
|
|
|
|
// Positive test - attach ROOT volume in correct state, to the vm not having root volume attached
|
|
@Test
|
|
public void attachRootVolumePositive() throws NoSuchFieldException, IllegalAccessException {
|
|
thrown.expect(NullPointerException.class);
|
|
volumeApiServiceImpl.attachVolumeToVM(2L, 6L, 0L);
|
|
}
|
|
|
|
// volume not Ready
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void testTakeSnapshotF1() throws ResourceAllocationException {
|
|
when(volumeDataFactoryMock.getVolume(anyLong())).thenReturn(volumeInfoMock);
|
|
when(volumeInfoMock.getState()).thenReturn(Volume.State.Allocated);
|
|
when(volumeInfoMock.getPoolId()).thenReturn(1L);
|
|
volumeApiServiceImpl.takeSnapshot(5L, Snapshot.MANUAL_POLICY_ID, 3L, null, false, null, false);
|
|
}
|
|
|
|
@Test
|
|
public void testTakeSnapshotF2() throws ResourceAllocationException {
|
|
when(volumeDataFactoryMock.getVolume(anyLong())).thenReturn(volumeInfoMock);
|
|
when(volumeInfoMock.getState()).thenReturn(Volume.State.Ready);
|
|
when(volumeInfoMock.getInstanceId()).thenReturn(null);
|
|
when(volumeInfoMock.getPoolId()).thenReturn(1L);
|
|
when(volumeServiceMock.takeSnapshot(Mockito.any(VolumeInfo.class))).thenReturn(snapshotInfoMock);
|
|
volumeApiServiceImpl.takeSnapshot(5L, Snapshot.MANUAL_POLICY_ID, 3L, null, false, null, false);
|
|
}
|
|
|
|
@Test
|
|
public void testNullGetVolumeNameFromCmd() {
|
|
when(createVolumeCmdMock.getVolumeName()).thenReturn(null);
|
|
Assert.assertNotNull(volumeApiServiceImpl.getVolumeNameFromCommand(createVolumeCmdMock));
|
|
}
|
|
|
|
@Test
|
|
public void testEmptyGetVolumeNameFromCmd() {
|
|
when(createVolumeCmdMock.getVolumeName()).thenReturn("");
|
|
Assert.assertNotNull(volumeApiServiceImpl.getVolumeNameFromCommand(createVolumeCmdMock));
|
|
}
|
|
|
|
@Test
|
|
public void testBlankGetVolumeNameFromCmd() {
|
|
when(createVolumeCmdMock.getVolumeName()).thenReturn(" ");
|
|
Assert.assertNotNull(volumeApiServiceImpl.getVolumeNameFromCommand(createVolumeCmdMock));
|
|
}
|
|
|
|
@Test
|
|
public void testNonEmptyGetVolumeNameFromCmd() {
|
|
when(createVolumeCmdMock.getVolumeName()).thenReturn("abc");
|
|
Assert.assertSame(volumeApiServiceImpl.getVolumeNameFromCommand(createVolumeCmdMock), "abc");
|
|
}
|
|
|
|
@Test
|
|
public void testUpdateMissingRootDiskControllerWithNullChainInfo() {
|
|
volumeApiServiceImpl.updateMissingRootDiskController(null, null);
|
|
verify(userVmManagerMock, times(0)).persistDeviceBusInfo(any(UserVmVO.class), anyString());
|
|
}
|
|
|
|
@Test
|
|
public void testUpdateMissingRootDiskControllerWithValidChainInfo() {
|
|
UserVmVO vm = userVmDaoMock.findById(1L);
|
|
assert vm.getType() == VirtualMachine.Type.User;
|
|
volumeApiServiceImpl.updateMissingRootDiskController(vm, "{\"diskDeviceBusName\":\"scsi0:0\",\"diskChain\":[\"[somedatastore] i-3-VM-somePath/ROOT-1.vmdk\"]}");
|
|
verify(userVmManagerMock, times(1)).persistDeviceBusInfo(any(UserVmVO.class), eq("scsi"));
|
|
}
|
|
|
|
@Test
|
|
/**
|
|
* Setting locationType for a non-managed storage should give an error
|
|
*/
|
|
public void testAllocSnapshotNonManagedStorageArchive() {
|
|
try {
|
|
volumeApiServiceImpl.allocSnapshot(6L, 1L, "test", Snapshot.LocationType.SECONDARY);
|
|
} catch (InvalidParameterValueException e) {
|
|
Assert.assertEquals(e.getMessage(), "VolumeId: 6 LocationType is supported only for managed storage");
|
|
return;
|
|
} catch (ResourceAllocationException e) {
|
|
Assert.fail("Unexpected excepiton " + e.getMessage());
|
|
}
|
|
|
|
Assert.fail("Expected Exception for archive in non-managed storage");
|
|
}
|
|
|
|
/**
|
|
* The resource limit check for primary storage should not be skipped for Volume in 'Uploaded' state.
|
|
* @throws NoSuchFieldException
|
|
* @throws IllegalAccessException
|
|
* @throws ResourceAllocationException
|
|
*/
|
|
@Test
|
|
public void testResourceLimitCheckForUploadedVolume() throws NoSuchFieldException, IllegalAccessException, ResourceAllocationException {
|
|
doThrow(new ResourceAllocationException("primary storage resource limit check failed", Resource.ResourceType.primary_storage)).when(volumeApiServiceImpl._resourceLimitMgr)
|
|
.checkResourceLimit(any(AccountVO.class), any(Resource.ResourceType.class), any(Long.class));
|
|
UserVmVO vm = Mockito.mock(UserVmVO.class);
|
|
VolumeInfo volumeToAttach = Mockito.mock(VolumeInfo.class);
|
|
when(volumeToAttach.getId()).thenReturn(9L);
|
|
when(volumeToAttach.getDataCenterId()).thenReturn(34L);
|
|
when(volumeToAttach.getVolumeType()).thenReturn(Volume.Type.DATADISK);
|
|
when(volumeToAttach.getInstanceId()).thenReturn(null);
|
|
when(userVmDaoMock.findById(anyLong())).thenReturn(vm);
|
|
when(vm.getType()).thenReturn(VirtualMachine.Type.User);
|
|
when(vm.getState()).thenReturn(State.Running);
|
|
when(vm.getDataCenterId()).thenReturn(34L);
|
|
when(volumeApiServiceImpl._volsDao.findByInstanceAndType(anyLong(), any(Volume.Type.class))).thenReturn(new ArrayList<>(10));
|
|
when(volumeApiServiceImpl.volFactory.getVolume(9L)).thenReturn(volumeToAttach);
|
|
when(volumeToAttach.getState()).thenReturn(Volume.State.Uploaded);
|
|
DataCenterVO zoneWithDisabledLocalStorage = Mockito.mock(DataCenterVO.class);
|
|
when(volumeApiServiceImpl._dcDao.findById(anyLong())).thenReturn(zoneWithDisabledLocalStorage);
|
|
when(zoneWithDisabledLocalStorage.isLocalStorageEnabled()).thenReturn(true);
|
|
try {
|
|
volumeApiServiceImpl.attachVolumeToVM(2L, 9L, null);
|
|
} catch (InvalidParameterValueException e) {
|
|
Assert.assertEquals(e.getMessage(), ("primary storage resource limit check failed"));
|
|
}
|
|
}
|
|
|
|
@After
|
|
public void tearDown() {
|
|
CallContext.unregister();
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void retrieveAndValidateVolumeTestVolumeNotFound() {
|
|
Mockito.doReturn(null).when(volumeDaoMock).findById(volumeMockId);
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void retrieveAndValidateVolumeTestCannotOperateOnVolumeDueToSnapshot() {
|
|
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).findById(volumeMockId);
|
|
Mockito.doReturn(false).when(snapshotManagerMock).canOperateOnVolume(volumeVoMock);
|
|
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void retrieveAndValidateVolumeTestVolumePluggedIntoVm() {
|
|
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).findById(volumeMockId);
|
|
Mockito.doReturn(vmInstanceMockId).when(volumeVoMock).getInstanceId();
|
|
|
|
Mockito.doReturn(true).when(snapshotManagerMock).canOperateOnVolume(volumeVoMock);
|
|
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void retrieveAndValidateVolumeTestStateUploadOpAndDownloadInProgress() {
|
|
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).findById(volumeMockId);
|
|
Mockito.doReturn(null).when(volumeVoMock).getInstanceId();
|
|
Mockito.doReturn(Volume.State.UploadOp).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(true).when(snapshotManagerMock).canOperateOnVolume(volumeVoMock);
|
|
Mockito.doReturn(volumeDataStoreVoMock).when(volumeDataStoreDaoMock).findByVolume(volumeMockId);
|
|
Mockito.doReturn(VMTemplateStorageResourceAssoc.Status.DOWNLOAD_IN_PROGRESS).when(volumeDataStoreVoMock).getDownloadState();
|
|
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void retrieveAndValidateVolumeTestStateNotUploaded() {
|
|
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).findById(volumeMockId);
|
|
Mockito.doReturn(null).when(volumeVoMock).getInstanceId();
|
|
Mockito.doReturn(Volume.State.NotUploaded).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(true).when(snapshotManagerMock).canOperateOnVolume(volumeVoMock);
|
|
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void retrieveAndValidateVolumeTestUploadInProgress() {
|
|
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).findById(volumeMockId);
|
|
Mockito.doReturn(null).when(volumeVoMock).getInstanceId();
|
|
Mockito.doReturn(Volume.State.UploadInProgress).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(true).when(snapshotManagerMock).canOperateOnVolume(volumeVoMock);
|
|
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
}
|
|
|
|
@Test
|
|
public void retrieveAndValidateVolumeTest() {
|
|
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).findById(volumeMockId);
|
|
Mockito.doReturn(null).when(volumeVoMock).getInstanceId();
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(true).when(snapshotManagerMock).canOperateOnVolume(volumeVoMock);
|
|
Mockito.doNothing().when(accountManagerMock).checkAccess(accountMock, null, true, volumeVoMock);
|
|
volumeApiServiceImpl.retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
|
|
Mockito.verify(accountManagerMock).checkAccess(accountMock, null, true, volumeVoMock);
|
|
}
|
|
|
|
@Test
|
|
public void destroyVolumeIfPossibleTestVolumeStateIsDestroy() {
|
|
Mockito.doReturn(Volume.State.Destroy).when(volumeVoMock).getState();
|
|
configureMocksForTestDestroyVolumeWhenVolume();
|
|
|
|
volumeApiServiceImpl.destroyVolumeIfPossible(volumeVoMock);
|
|
|
|
verifyMocksForTestDestroyVolumeWhenVolumeIsNotInRightState();
|
|
}
|
|
|
|
@Test
|
|
public void destroyVolumeIfPossibleTestVolumeStateIsExpunging() {
|
|
Mockito.doReturn(Volume.State.Expunging).when(volumeVoMock).getState();
|
|
configureMocksForTestDestroyVolumeWhenVolume();
|
|
|
|
volumeApiServiceImpl.destroyVolumeIfPossible(volumeVoMock);
|
|
|
|
verifyMocksForTestDestroyVolumeWhenVolumeIsNotInRightState();
|
|
}
|
|
|
|
@Test
|
|
public void destroyVolumeIfPossibleTestVolumeStateIsExpunged() {
|
|
Mockito.doReturn(Volume.State.Expunged).when(volumeVoMock).getState();
|
|
configureMocksForTestDestroyVolumeWhenVolume();
|
|
|
|
volumeApiServiceImpl.destroyVolumeIfPossible(volumeVoMock);
|
|
|
|
verifyMocksForTestDestroyVolumeWhenVolumeIsNotInRightState();
|
|
}
|
|
|
|
@Test
|
|
public void destroyVolumeIfPossibleTestVolumeStateReady() {
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
configureMocksForTestDestroyVolumeWhenVolume();
|
|
|
|
volumeApiServiceImpl.destroyVolumeIfPossible(volumeVoMock);
|
|
|
|
Mockito.verify(volumeServiceMock, Mockito.times(1)).destroyVolume(volumeMockId);
|
|
Mockito.verify(resourceLimitServiceMock, Mockito.times(1)).decrementResourceCount(accountMockId, ResourceType.volume, true);
|
|
Mockito.verify(resourceLimitServiceMock, Mockito.times(1)).decrementResourceCount(accountMockId, ResourceType.primary_storage, true, volumeSizeMock);
|
|
}
|
|
|
|
private void verifyMocksForTestDestroyVolumeWhenVolumeIsNotInRightState() {
|
|
Mockito.verify(volumeServiceMock, Mockito.times(0)).destroyVolume(volumeMockId);
|
|
Mockito.verify(resourceLimitServiceMock, Mockito.times(0)).decrementResourceCount(accountMockId, ResourceType.volume, true);
|
|
Mockito.verify(resourceLimitServiceMock, Mockito.times(0)).decrementResourceCount(accountMockId, ResourceType.primary_storage, true, volumeSizeMock);
|
|
}
|
|
|
|
private void configureMocksForTestDestroyVolumeWhenVolume() {
|
|
Mockito.doReturn(accountMockId).when(volumeVoMock).getAccountId();
|
|
Mockito.doReturn(true).when(volumeVoMock).isDisplayVolume();
|
|
|
|
Mockito.doNothing().when(volumeServiceMock).destroyVolume(volumeMockId);
|
|
Mockito.doNothing().when(resourceLimitServiceMock).decrementResourceCount(accountMockId, ResourceType.volume, true);
|
|
Mockito.doNothing().when(resourceLimitServiceMock).decrementResourceCount(accountMockId, ResourceType.primary_storage, true, volumeSizeMock);
|
|
}
|
|
|
|
@Test
|
|
public void expungeVolumesInPrimaryStorageIfNeededTestVolumeNotInPrimaryDataStore() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(null).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Primary);
|
|
|
|
volumeApiServiceImpl.expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.verify(volumeServiceMock, Mockito.times(0)).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.verify(asyncCallFutureVolumeapiResultMock, Mockito.times(0)).get();
|
|
}
|
|
|
|
@Test
|
|
public void expungeVolumesInPrimaryStorageIfNeededTestVolumeInPrimaryDataStore() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(volumeInfoMock).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Primary);
|
|
|
|
volumeApiServiceImpl.expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.verify(volumeServiceMock, Mockito.times(1)).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.verify(asyncCallFutureVolumeapiResultMock, Mockito.times(1)).get();
|
|
}
|
|
|
|
@Test(expected = InterruptedException.class)
|
|
public void expungeVolumesInPrimaryStorageIfNeededTestThrowingInterruptedException() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(volumeInfoMock).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Primary);
|
|
Mockito.doThrow(InterruptedException.class).when(asyncCallFutureVolumeapiResultMock).get();
|
|
|
|
volumeApiServiceImpl.expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
}
|
|
|
|
@Test(expected = ExecutionException.class)
|
|
public void expungeVolumesInPrimaryStorageIfNeededTestThrowingExecutionException() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(volumeInfoMock).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Primary);
|
|
Mockito.doThrow(ExecutionException.class).when(asyncCallFutureVolumeapiResultMock).get();
|
|
|
|
volumeApiServiceImpl.expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
}
|
|
|
|
@Test
|
|
public void expungeVolumesInSecondaryStorageIfNeededTestVolumeNotFoundInSecondaryStorage() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(null).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Image);
|
|
Mockito.doNothing().when(resourceLimitServiceMock).decrementResourceCount(accountMockId, ResourceType.secondary_storage, volumeSizeMock);
|
|
Mockito.doReturn(accountMockId).when(volumeInfoMock).getAccountId();
|
|
Mockito.doReturn(volumeSizeMock).when(volumeInfoMock).getSize();
|
|
|
|
volumeApiServiceImpl.expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.verify(volumeServiceMock, Mockito.times(0)).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.verify(asyncCallFutureVolumeapiResultMock, Mockito.times(0)).get();
|
|
Mockito.verify(resourceLimitServiceMock, Mockito.times(0)).decrementResourceCount(accountMockId, ResourceType.secondary_storage, volumeSizeMock);
|
|
}
|
|
|
|
@Test
|
|
public void expungeVolumesInSecondaryStorageIfNeededTestVolumeFoundInSecondaryStorage() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(volumeInfoMock).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Image);
|
|
Mockito.doNothing().when(resourceLimitServiceMock).decrementResourceCount(accountMockId, ResourceType.secondary_storage, volumeSizeMock);
|
|
Mockito.doReturn(accountMockId).when(volumeInfoMock).getAccountId();
|
|
Mockito.doReturn(volumeSizeMock).when(volumeInfoMock).getSize();
|
|
|
|
volumeApiServiceImpl.expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.verify(volumeServiceMock, Mockito.times(1)).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.verify(asyncCallFutureVolumeapiResultMock, Mockito.times(1)).get();
|
|
Mockito.verify(resourceLimitServiceMock, Mockito.times(1)).decrementResourceCount(accountMockId, ResourceType.secondary_storage, volumeSizeMock);
|
|
}
|
|
|
|
@Test(expected = InterruptedException.class)
|
|
public void expungeVolumesInSecondaryStorageIfNeededTestthrowinInterruptedException() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(volumeInfoMock).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Image);
|
|
Mockito.doNothing().when(resourceLimitServiceMock).decrementResourceCount(accountMockId, ResourceType.secondary_storage, volumeSizeMock);
|
|
Mockito.doReturn(accountMockId).when(volumeInfoMock).getAccountId();
|
|
Mockito.doReturn(volumeSizeMock).when(volumeInfoMock).getSize();
|
|
|
|
Mockito.doThrow(InterruptedException.class).when(asyncCallFutureVolumeapiResultMock).get();
|
|
|
|
volumeApiServiceImpl.expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
|
|
}
|
|
|
|
@Test(expected = ExecutionException.class)
|
|
public void expungeVolumesInSecondaryStorageIfNeededTestthrowinExecutionException() throws InterruptedException, ExecutionException {
|
|
Mockito.doReturn(asyncCallFutureVolumeapiResultMock).when(volumeServiceMock).expungeVolumeAsync(volumeInfoMock);
|
|
Mockito.doReturn(volumeInfoMock).when(volumeDataFactoryMock).getVolume(volumeMockId, DataStoreRole.Image);
|
|
Mockito.doNothing().when(resourceLimitServiceMock).decrementResourceCount(accountMockId, ResourceType.secondary_storage, volumeSizeMock);
|
|
Mockito.doReturn(accountMockId).when(volumeInfoMock).getAccountId();
|
|
Mockito.doReturn(volumeSizeMock).when(volumeInfoMock).getSize();
|
|
|
|
Mockito.doThrow(ExecutionException.class).when(asyncCallFutureVolumeapiResultMock).get();
|
|
|
|
volumeApiServiceImpl.expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
|
|
}
|
|
|
|
@Test
|
|
public void cleanVolumesCacheTest() {
|
|
List<VolumeInfo> volumeInfos = new ArrayList<>();
|
|
VolumeInfo volumeInfoMock1 = Mockito.mock(VolumeInfo.class);
|
|
VolumeInfo volumeInfoMock2 = Mockito.mock(VolumeInfo.class);
|
|
|
|
DataStore dataStoreMock1 = Mockito.mock(DataStore.class);
|
|
DataStore dataStoreMock2 = Mockito.mock(DataStore.class);
|
|
Mockito.doReturn(dataStoreMock1).when(volumeInfoMock1).getDataStore();
|
|
Mockito.doReturn(dataStoreMock2).when(volumeInfoMock2).getDataStore();
|
|
|
|
volumeInfos.add(volumeInfoMock1);
|
|
volumeInfos.add(volumeInfoMock2);
|
|
|
|
Mockito.doReturn(volumeInfos).when(volumeDataFactoryMock).listVolumeOnCache(volumeMockId);
|
|
|
|
volumeApiServiceImpl.cleanVolumesCache(volumeVoMock);
|
|
|
|
Mockito.verify(dataStoreMock1).getName();
|
|
Mockito.verify(dataStoreMock2).getName();
|
|
|
|
Mockito.verify(volumeInfoMock1).delete();
|
|
Mockito.verify(volumeInfoMock2).delete();
|
|
}
|
|
|
|
@Test
|
|
public void deleteVolumeTestVolumeStateAllocated() throws InterruptedException, ExecutionException, NoTransitionException {
|
|
Mockito.doReturn(Volume.State.Allocated).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(volumeVoMock).when(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).cleanVolumesCache(volumeVoMock);
|
|
|
|
Mockito.doReturn(true).when(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.doReturn(true).when(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
boolean result = volumeApiServiceImpl.deleteVolume(volumeMockId, accountMock);
|
|
|
|
assertTrue(result);
|
|
Mockito.verify(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.verify(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.verify(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.verify(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).cleanVolumesCache(volumeVoMock);
|
|
}
|
|
|
|
@Test
|
|
public void deleteVolumeTestVolumeStateReady() throws InterruptedException, ExecutionException, NoTransitionException {
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(volumeVoMock).when(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).cleanVolumesCache(volumeVoMock);
|
|
|
|
Mockito.doReturn(true).when(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.doReturn(true).when(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
boolean result = volumeApiServiceImpl.deleteVolume(volumeMockId, accountMock);
|
|
|
|
assertTrue(result);
|
|
Mockito.verify(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.verify(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.verify(volumeDaoMock, Mockito.times(0)).remove(volumeMockId);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(1)).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(1)).expungeVolumesInSecondaryStorageIfNeeded(volumeVoMock);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(1)).cleanVolumesCache(volumeVoMock);
|
|
}
|
|
|
|
@Test
|
|
public void deleteVolumeTestVolumeStateReadyThrowingInterruptedException() throws InterruptedException, ExecutionException, NoTransitionException {
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(volumeVoMock).when(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.doThrow(InterruptedException.class).when(volumeApiServiceImpl).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.doReturn(true).when(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.doReturn(true).when(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
boolean result = volumeApiServiceImpl.deleteVolume(volumeMockId, accountMock);
|
|
|
|
assertFalse(result);
|
|
Mockito.verify(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.verify(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.verify(volumeDaoMock, Mockito.times(0)).remove(volumeMockId);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
}
|
|
|
|
@Test
|
|
public void deleteVolumeTestVolumeStateReadyThrowingExecutionException() throws InterruptedException, ExecutionException, NoTransitionException {
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(volumeVoMock).when(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.doThrow(ExecutionException.class).when(volumeApiServiceImpl).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.doReturn(true).when(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.doReturn(true).when(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
boolean result = volumeApiServiceImpl.deleteVolume(volumeMockId, accountMock);
|
|
|
|
assertFalse(result);
|
|
Mockito.verify(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.verify(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.verify(volumeDaoMock, Mockito.times(0)).remove(volumeMockId);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
}
|
|
|
|
@Test
|
|
public void deleteVolumeTestVolumeStateReadyThrowingNoTransitionException() throws InterruptedException, ExecutionException, NoTransitionException {
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(volumeVoMock).when(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.doThrow(NoTransitionException.class).when(volumeApiServiceImpl).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.doReturn(true).when(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.doReturn(true).when(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
boolean result = volumeApiServiceImpl.deleteVolume(volumeMockId, accountMock);
|
|
|
|
assertFalse(result);
|
|
Mockito.verify(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.verify(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.verify(volumeDaoMock, Mockito.times(0)).remove(volumeMockId);
|
|
Mockito.verify(volumeApiServiceImpl, Mockito.times(0)).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
}
|
|
|
|
@Test(expected = RuntimeException.class)
|
|
public void deleteVolumeTestVolumeStateReadyThrowingRuntimeException() throws InterruptedException, ExecutionException, NoTransitionException {
|
|
Mockito.doReturn(Volume.State.Ready).when(volumeVoMock).getState();
|
|
|
|
Mockito.doReturn(volumeVoMock).when(volumeApiServiceImpl).retrieveAndValidateVolume(volumeMockId, accountMock);
|
|
Mockito.doNothing().when(volumeApiServiceImpl).destroyVolumeIfPossible(volumeVoMock);
|
|
Mockito.doThrow(RuntimeException.class).when(volumeApiServiceImpl).expungeVolumesInPrimaryStorageIfNeeded(volumeVoMock);
|
|
|
|
Mockito.doReturn(true).when(volumeDaoMock).remove(volumeMockId);
|
|
Mockito.doReturn(true).when(volumeApiServiceImpl).stateTransitTo(volumeVoMock, Volume.Event.DestroyRequested);
|
|
|
|
volumeApiServiceImpl.deleteVolume(volumeMockId, accountMock);
|
|
}
|
|
}
|