mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
1a55a93f04
Unhides snapshot.backup.rightafter from global configuration If snapshot.backup.rightafter is set to false (defaults to true), snapshots are not backed up to secondary storage
644 lines
26 KiB
Java
644 lines
26 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.template;
|
|
|
|
|
|
import com.cloud.agent.AgentManager;
|
|
import com.cloud.api.query.dao.UserVmJoinDao;
|
|
import com.cloud.configuration.Resource;
|
|
import com.cloud.dc.dao.DataCenterDao;
|
|
import com.cloud.domain.dao.DomainDao;
|
|
import com.cloud.event.dao.UsageEventDao;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.exception.ResourceAllocationException;
|
|
import com.cloud.host.Status;
|
|
import com.cloud.host.dao.HostDao;
|
|
import com.cloud.hypervisor.Hypervisor;
|
|
import com.cloud.projects.ProjectManager;
|
|
import com.cloud.storage.GuestOSVO;
|
|
import com.cloud.storage.Snapshot;
|
|
import com.cloud.storage.SnapshotVO;
|
|
import com.cloud.storage.StorageManager;
|
|
import com.cloud.storage.StoragePool;
|
|
import com.cloud.storage.StoragePoolStatus;
|
|
import com.cloud.storage.VMTemplateStoragePoolVO;
|
|
import com.cloud.storage.VMTemplateStorageResourceAssoc;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.dao.GuestOSDao;
|
|
import com.cloud.storage.dao.LaunchPermissionDao;
|
|
import com.cloud.storage.dao.SnapshotDao;
|
|
import com.cloud.storage.dao.StoragePoolHostDao;
|
|
import com.cloud.storage.dao.VMTemplateDao;
|
|
import com.cloud.storage.dao.VMTemplatePoolDao;
|
|
import com.cloud.storage.dao.VMTemplateZoneDao;
|
|
import com.cloud.storage.dao.VolumeDao;
|
|
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.component.ComponentContext;
|
|
import com.cloud.utils.concurrency.NamedThreadFactory;
|
|
import com.cloud.utils.exception.CloudRuntimeException;
|
|
import com.cloud.vm.dao.UserVmDao;
|
|
import com.cloud.vm.dao.VMInstanceDao;
|
|
import org.apache.cloudstack.api.command.user.template.CreateTemplateCmd;
|
|
import org.apache.cloudstack.context.CallContext;
|
|
import org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.EndPointSelector;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.PrimaryDataStore;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotDataFactory;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.StorageCacheManager;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.StorageStrategyFactory;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateDataFactory;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateService;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.VolumeDataFactory;
|
|
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
|
|
import org.apache.cloudstack.framework.messagebus.MessageBus;
|
|
import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
|
|
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
|
|
import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO;
|
|
import org.apache.cloudstack.test.utils.SpringUtils;
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.mockito.Mockito;
|
|
import org.mockito.invocation.InvocationOnMock;
|
|
import org.mockito.stubbing.Answer;
|
|
import org.springframework.context.annotation.Bean;
|
|
import org.springframework.context.annotation.ComponentScan;
|
|
import org.springframework.context.annotation.Configuration;
|
|
import org.springframework.context.annotation.FilterType;
|
|
import org.springframework.core.type.classreading.MetadataReader;
|
|
import org.springframework.core.type.classreading.MetadataReaderFactory;
|
|
import org.springframework.core.type.filter.TypeFilter;
|
|
import org.springframework.test.context.ContextConfiguration;
|
|
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
|
|
import org.springframework.test.context.support.AnnotationConfigContextLoader;
|
|
|
|
import javax.inject.Inject;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.BlockingQueue;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import java.util.concurrent.ThreadFactory;
|
|
import java.util.concurrent.ThreadPoolExecutor;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.mockito.Matchers.any;
|
|
import static org.mockito.Matchers.anyBoolean;
|
|
import static org.mockito.Matchers.anyLong;
|
|
import static org.mockito.Mockito.doNothing;
|
|
import static org.mockito.Mockito.mock;
|
|
import static org.mockito.Mockito.when;
|
|
import static org.mockito.Mockito.eq;
|
|
|
|
@RunWith(SpringJUnit4ClassRunner.class)
|
|
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
|
|
public class TemplateManagerImplTest {
|
|
|
|
@Inject
|
|
TemplateManagerImpl templateManager = new TemplateManagerImpl();
|
|
|
|
@Inject
|
|
DataStoreManager dataStoreManager;
|
|
|
|
@Inject
|
|
VMTemplateDao vmTemplateDao;
|
|
|
|
@Inject
|
|
VMTemplatePoolDao vmTemplatePoolDao;
|
|
|
|
@Inject
|
|
TemplateDataStoreDao templateDataStoreDao;
|
|
|
|
@Inject
|
|
StoragePoolHostDao storagePoolHostDao;
|
|
|
|
@Inject
|
|
PrimaryDataStoreDao primaryDataStoreDao;
|
|
|
|
@Inject
|
|
ResourceLimitService resourceLimitMgr;
|
|
|
|
@Inject
|
|
ImageStoreDao imgStoreDao;
|
|
|
|
@Inject
|
|
GuestOSDao guestOSDao;
|
|
|
|
@Inject
|
|
VMTemplateDao tmpltDao;
|
|
|
|
@Inject
|
|
SnapshotDao snapshotDao;
|
|
|
|
@Inject
|
|
StorageStrategyFactory storageStrategyFactory;
|
|
|
|
public class CustomThreadPoolExecutor extends ThreadPoolExecutor {
|
|
AtomicInteger ai = new AtomicInteger(0);
|
|
public CustomThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
|
|
BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
|
|
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
|
|
}
|
|
|
|
@Override
|
|
protected void beforeExecute(Thread t, Runnable r) {
|
|
ai.addAndGet(1);
|
|
}
|
|
|
|
public int getCount() {
|
|
try {
|
|
// Wait for some time to give before execute to run. Otherwise the tests that
|
|
// assert and check that template seeding has been scheduled may fail. If tests
|
|
// are seen to fail, consider increasing the sleep time.
|
|
Thread.sleep(1000);
|
|
return ai.get();
|
|
} catch (Exception e) {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Before
|
|
public void setUp() {
|
|
ComponentContext.initComponentsLifeCycle();
|
|
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);
|
|
}
|
|
|
|
@After
|
|
public void tearDown() {
|
|
CallContext.unregister();
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void testVerifyTemplateIdOfSystemTemplate() {
|
|
templateManager.verifyTemplateId(1L);
|
|
}
|
|
|
|
public void testVerifyTemplateIdOfNonSystemTemplate() {
|
|
templateManager.verifyTemplateId(1L);
|
|
}
|
|
|
|
@Test
|
|
public void testPrepareTemplateIsSeeded() {
|
|
VMTemplateVO mockTemplate = mock(VMTemplateVO.class);
|
|
when(mockTemplate.getId()).thenReturn(202l);
|
|
|
|
StoragePoolVO mockPool = mock(StoragePoolVO.class);
|
|
when(mockPool.getId()).thenReturn(2l);
|
|
|
|
PrimaryDataStore mockPrimaryDataStore = mock(PrimaryDataStore.class);
|
|
when(mockPrimaryDataStore.getId()).thenReturn(2l);
|
|
|
|
VMTemplateStoragePoolVO mockTemplateStore = mock(VMTemplateStoragePoolVO.class);
|
|
when(mockTemplateStore.getDownloadState()).thenReturn(VMTemplateStorageResourceAssoc.Status.DOWNLOADED);
|
|
|
|
when(dataStoreManager.getPrimaryDataStore(anyLong())).thenReturn(mockPrimaryDataStore);
|
|
when(vmTemplateDao.findById(anyLong(), anyBoolean())).thenReturn(mockTemplate);
|
|
when(vmTemplatePoolDao.findByPoolTemplate(anyLong(), anyLong())).thenReturn(mockTemplateStore);
|
|
|
|
doNothing().when(mockTemplateStore).setMarkedForGC(anyBoolean());
|
|
|
|
VMTemplateStoragePoolVO returnObject = templateManager.prepareTemplateForCreate(mockTemplate, (StoragePool) mockPrimaryDataStore);
|
|
assertTrue("Test template is already seeded", returnObject == mockTemplateStore);
|
|
}
|
|
|
|
@Test
|
|
public void testPrepareTemplateNotDownloaded() {
|
|
VMTemplateVO mockTemplate = mock(VMTemplateVO.class);
|
|
when(mockTemplate.getId()).thenReturn(202l);
|
|
|
|
StoragePoolVO mockPool = mock(StoragePoolVO.class);
|
|
when(mockPool.getId()).thenReturn(2l);
|
|
|
|
PrimaryDataStore mockPrimaryDataStore = mock(PrimaryDataStore.class);
|
|
when(mockPrimaryDataStore.getId()).thenReturn(2l);
|
|
when(mockPrimaryDataStore.getDataCenterId()).thenReturn(1l);
|
|
|
|
when(dataStoreManager.getPrimaryDataStore(anyLong())).thenReturn(mockPrimaryDataStore);
|
|
when(vmTemplateDao.findById(anyLong(), anyBoolean())).thenReturn(mockTemplate);
|
|
when(vmTemplatePoolDao.findByPoolTemplate(anyLong(), anyLong())).thenReturn(null);
|
|
when(templateDataStoreDao.findByTemplateZoneDownloadStatus(202l, 1l, VMTemplateStorageResourceAssoc.Status.DOWNLOADED)).thenReturn(null);
|
|
|
|
VMTemplateStoragePoolVO returnObject = templateManager.prepareTemplateForCreate(mockTemplate, (StoragePool) mockPrimaryDataStore);
|
|
assertTrue("Test template is not ready", returnObject == null);
|
|
}
|
|
|
|
@Test(expected = CloudRuntimeException.class)
|
|
public void testPrepareTemplateNoHostConnectedToPool() {
|
|
VMTemplateVO mockTemplate = mock(VMTemplateVO.class);
|
|
when(mockTemplate.getId()).thenReturn(202l);
|
|
|
|
StoragePoolVO mockPool = mock(StoragePoolVO.class);
|
|
when(mockPool.getId()).thenReturn(2l);
|
|
|
|
PrimaryDataStore mockPrimaryDataStore = mock(PrimaryDataStore.class);
|
|
when(mockPrimaryDataStore.getId()).thenReturn(2l);
|
|
when(mockPrimaryDataStore.getDataCenterId()).thenReturn(1l);
|
|
|
|
TemplateDataStoreVO mockTemplateDataStore = mock(TemplateDataStoreVO.class);
|
|
|
|
when(dataStoreManager.getPrimaryDataStore(anyLong())).thenReturn(mockPrimaryDataStore);
|
|
when(vmTemplateDao.findById(anyLong(), anyBoolean())).thenReturn(mockTemplate);
|
|
when(vmTemplatePoolDao.findByPoolTemplate(anyLong(), anyLong())).thenReturn(null);
|
|
when(templateDataStoreDao.findByTemplateZoneDownloadStatus(202l, 1l, VMTemplateStorageResourceAssoc.Status.DOWNLOADED)).thenReturn(mockTemplateDataStore);
|
|
when(storagePoolHostDao.listByHostStatus(2l, Status.Up)).thenReturn(null);
|
|
|
|
templateManager.prepareTemplateForCreate(mockTemplate, (StoragePool) mockPrimaryDataStore);
|
|
}
|
|
|
|
@Test(expected = InvalidParameterValueException.class)
|
|
public void testPrepareTemplateInvalidTemplate() {
|
|
when(vmTemplateDao.findById(anyLong())).thenReturn(null);
|
|
templateManager.prepareTemplate(202, 1, null);
|
|
}
|
|
|
|
@Test
|
|
public void testTemplateScheduledForDownloadInOnePool() {
|
|
VMTemplateVO mockTemplate = mock(VMTemplateVO.class);
|
|
StoragePoolVO mockPool = mock(StoragePoolVO.class);
|
|
PrimaryDataStore mockPrimaryDataStore = mock(PrimaryDataStore.class);
|
|
VMTemplateStoragePoolVO mockTemplateStore = mock(VMTemplateStoragePoolVO.class);
|
|
|
|
when(mockPrimaryDataStore.getId()).thenReturn(2l);
|
|
when(mockPool.getId()).thenReturn(2l);
|
|
when(mockPool.getStatus()).thenReturn(StoragePoolStatus.Up);
|
|
when(mockPool.getDataCenterId()).thenReturn(1l);
|
|
when(mockTemplate.getId()).thenReturn(202l);
|
|
when(mockTemplateStore.getDownloadState()).thenReturn(VMTemplateStorageResourceAssoc.Status.DOWNLOADED);
|
|
when(vmTemplateDao.findById(anyLong())).thenReturn(mockTemplate);
|
|
when(dataStoreManager.getPrimaryDataStore(anyLong())).thenReturn(mockPrimaryDataStore);
|
|
when(vmTemplateDao.findById(anyLong(), anyBoolean())).thenReturn(mockTemplate);
|
|
when(vmTemplatePoolDao.findByPoolTemplate(anyLong(), anyLong())).thenReturn(mockTemplateStore);
|
|
when(primaryDataStoreDao.findById(anyLong())).thenReturn(mockPool);
|
|
|
|
doNothing().when(mockTemplateStore).setMarkedForGC(anyBoolean());
|
|
|
|
ExecutorService preloadExecutor = new CustomThreadPoolExecutor(8, 8, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(),
|
|
new NamedThreadFactory("Template-Preloader"));
|
|
templateManager._preloadExecutor = preloadExecutor;
|
|
|
|
templateManager.prepareTemplate(202, 1, 2l);
|
|
assertTrue("Test template is scheduled for seeding to on pool", ((CustomThreadPoolExecutor)preloadExecutor).getCount() == 1);
|
|
}
|
|
|
|
@Test
|
|
public void testTemplateScheduledForDownloadInDisabledPool() {
|
|
VMTemplateVO mockTemplate = mock(VMTemplateVO.class);
|
|
StoragePoolVO mockPool = mock(StoragePoolVO.class);
|
|
PrimaryDataStore mockPrimaryDataStore = mock(PrimaryDataStore.class);
|
|
VMTemplateStoragePoolVO mockTemplateStore = mock(VMTemplateStoragePoolVO.class);
|
|
|
|
when(mockPrimaryDataStore.getId()).thenReturn(2l);
|
|
when(mockPool.getId()).thenReturn(2l);
|
|
when(mockPool.getStatus()).thenReturn(StoragePoolStatus.Disabled);
|
|
when(mockPool.getDataCenterId()).thenReturn(1l);
|
|
when(mockTemplate.getId()).thenReturn(202l);
|
|
when(mockTemplateStore.getDownloadState()).thenReturn(VMTemplateStorageResourceAssoc.Status.DOWNLOADED);
|
|
when(vmTemplateDao.findById(anyLong())).thenReturn(mockTemplate);
|
|
when(dataStoreManager.getPrimaryDataStore(anyLong())).thenReturn(mockPrimaryDataStore);
|
|
when(vmTemplateDao.findById(anyLong(), anyBoolean())).thenReturn(mockTemplate);
|
|
when(vmTemplatePoolDao.findByPoolTemplate(anyLong(), anyLong())).thenReturn(mockTemplateStore);
|
|
when(primaryDataStoreDao.findById(anyLong())).thenReturn(mockPool);
|
|
|
|
doNothing().when(mockTemplateStore).setMarkedForGC(anyBoolean());
|
|
|
|
ExecutorService preloadExecutor = new CustomThreadPoolExecutor(8, 8, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(),
|
|
new NamedThreadFactory("Template-Preloader"));
|
|
templateManager._preloadExecutor = preloadExecutor;
|
|
|
|
templateManager.prepareTemplate(202, 1, 2l);
|
|
assertTrue("Test template is not scheduled for seeding on disabled pool", ((CustomThreadPoolExecutor)preloadExecutor).getCount() == 0);
|
|
}
|
|
|
|
@Test
|
|
public void testTemplateScheduledForDownloadInMultiplePool() {
|
|
VMTemplateVO mockTemplate = mock(VMTemplateVO.class);
|
|
PrimaryDataStore mockPrimaryDataStore = mock(PrimaryDataStore.class);
|
|
VMTemplateStoragePoolVO mockTemplateStore = mock(VMTemplateStoragePoolVO.class);
|
|
List<StoragePoolVO> pools = new ArrayList<StoragePoolVO>();
|
|
|
|
StoragePoolVO mockPool1 = mock(StoragePoolVO.class);
|
|
when(mockPool1.getId()).thenReturn(2l);
|
|
when(mockPool1.getStatus()).thenReturn(StoragePoolStatus.Up);
|
|
when(mockPool1.getDataCenterId()).thenReturn(1l);
|
|
StoragePoolVO mockPool2 = mock(StoragePoolVO.class);
|
|
when(mockPool2.getId()).thenReturn(3l);
|
|
when(mockPool2.getStatus()).thenReturn(StoragePoolStatus.Up);
|
|
when(mockPool2.getDataCenterId()).thenReturn(1l);
|
|
StoragePoolVO mockPool3 = mock(StoragePoolVO.class);
|
|
when(mockPool3.getId()).thenReturn(4l);
|
|
when(mockPool3.getStatus()).thenReturn(StoragePoolStatus.Up);
|
|
when(mockPool3.getDataCenterId()).thenReturn(2l);
|
|
pools.add(mockPool1);
|
|
pools.add(mockPool2);
|
|
pools.add(mockPool3);
|
|
|
|
when(mockPrimaryDataStore.getId()).thenReturn(2l);
|
|
when(mockTemplate.getId()).thenReturn(202l);
|
|
when(mockTemplateStore.getDownloadState()).thenReturn(VMTemplateStorageResourceAssoc.Status.DOWNLOADED);
|
|
when(vmTemplateDao.findById(anyLong())).thenReturn(mockTemplate);
|
|
when(dataStoreManager.getPrimaryDataStore(anyLong())).thenReturn(mockPrimaryDataStore);
|
|
when(vmTemplateDao.findById(anyLong(), anyBoolean())).thenReturn(mockTemplate);
|
|
when(vmTemplatePoolDao.findByPoolTemplate(anyLong(), anyLong())).thenReturn(mockTemplateStore);
|
|
when(primaryDataStoreDao.findById(2l)).thenReturn(mockPool1);
|
|
when(primaryDataStoreDao.findById(3l)).thenReturn(mockPool2);
|
|
when(primaryDataStoreDao.findById(4l)).thenReturn(mockPool3);
|
|
when(primaryDataStoreDao.listByStatus(StoragePoolStatus.Up)).thenReturn(pools);
|
|
|
|
doNothing().when(mockTemplateStore).setMarkedForGC(anyBoolean());
|
|
|
|
ExecutorService preloadExecutor = new CustomThreadPoolExecutor(8, 8, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(),
|
|
new NamedThreadFactory("Template-Preloader"));
|
|
templateManager._preloadExecutor = preloadExecutor;
|
|
|
|
templateManager.prepareTemplate(202, 1, null);
|
|
assertTrue("Test template is scheduled for seeding to on pool", ((CustomThreadPoolExecutor) preloadExecutor).getCount() == 2);
|
|
}
|
|
|
|
@Test
|
|
public void testCreatePrivateTemplateRecordForRegionStore() throws ResourceAllocationException {
|
|
|
|
CreateTemplateCmd mockCreateCmd = mock(CreateTemplateCmd.class);
|
|
when(mockCreateCmd.getTemplateName()).thenReturn("test");
|
|
when(mockCreateCmd.getTemplateTag()).thenReturn(null);
|
|
when(mockCreateCmd.getBits()).thenReturn(64);
|
|
when(mockCreateCmd.getRequiresHvm()).thenReturn(true);
|
|
when(mockCreateCmd.isPasswordEnabled()).thenReturn(false);
|
|
when(mockCreateCmd.isPublic()).thenReturn(false);
|
|
when(mockCreateCmd.isFeatured()).thenReturn(false);
|
|
when(mockCreateCmd.isDynamicallyScalable()).thenReturn(false);
|
|
when(mockCreateCmd.getVolumeId()).thenReturn(null);
|
|
when(mockCreateCmd.getSnapshotId()).thenReturn(1L);
|
|
when(mockCreateCmd.getOsTypeId()).thenReturn(1L);
|
|
when(mockCreateCmd.getEventDescription()).thenReturn("test");
|
|
when(mockCreateCmd.getDetails()).thenReturn(null);
|
|
|
|
Account mockTemplateOwner = mock(Account.class);
|
|
|
|
SnapshotVO mockSnapshot = mock(SnapshotVO.class);
|
|
when(snapshotDao.findById(anyLong())).thenReturn(mockSnapshot);
|
|
|
|
when(mockSnapshot.getVolumeId()).thenReturn(1L);
|
|
when(mockSnapshot.getState()).thenReturn(Snapshot.State.BackedUp);
|
|
when(mockSnapshot.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.XenServer);
|
|
|
|
doNothing().when(resourceLimitMgr).checkResourceLimit(any(Account.class), eq(Resource.ResourceType.template));
|
|
doNothing().when(resourceLimitMgr).checkResourceLimit(any(Account.class), eq(Resource.ResourceType.secondary_storage), anyLong());
|
|
|
|
GuestOSVO mockGuestOS = mock(GuestOSVO.class);
|
|
when(guestOSDao.findById(anyLong())).thenReturn(mockGuestOS);
|
|
|
|
when(tmpltDao.getNextInSequence(eq(Long.class), eq("id"))).thenReturn(1L);
|
|
|
|
List<ImageStoreVO> mockRegionStores = new ArrayList<>();
|
|
ImageStoreVO mockRegionStore = mock(ImageStoreVO.class);
|
|
mockRegionStores.add(mockRegionStore);
|
|
when(imgStoreDao.findRegionImageStores()).thenReturn(mockRegionStores);
|
|
|
|
when(tmpltDao.persist(any(VMTemplateVO.class))).thenAnswer(new Answer<VMTemplateVO>() {
|
|
@Override
|
|
public VMTemplateVO answer(InvocationOnMock invocationOnMock) throws Throwable {
|
|
Object[] args = invocationOnMock.getArguments();
|
|
return (VMTemplateVO)args[0];
|
|
}
|
|
});
|
|
|
|
VMTemplateVO template = templateManager.createPrivateTemplateRecord(mockCreateCmd, mockTemplateOwner);
|
|
assertTrue("Template in a region store should have cross zones set", template.isCrossZones());
|
|
}
|
|
|
|
@Configuration
|
|
@ComponentScan(basePackageClasses = {TemplateManagerImpl.class},
|
|
includeFilters = {@ComponentScan.Filter(value = TestConfiguration.Library.class, type = FilterType.CUSTOM)},
|
|
useDefaultFilters = false)
|
|
public static class TestConfiguration extends SpringUtils.CloudStackTestConfiguration {
|
|
|
|
@Bean
|
|
public DataStoreManager dataStoreManager() {
|
|
return Mockito.mock(DataStoreManager.class);
|
|
}
|
|
|
|
@Bean
|
|
public VMTemplateDao vmTemplateDao() {
|
|
return Mockito.mock(VMTemplateDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public StorageStrategyFactory storageStrategyFactory() {
|
|
return Mockito.mock(StorageStrategyFactory.class);
|
|
}
|
|
|
|
@Bean
|
|
public VMTemplatePoolDao vmTemplatePoolDao() {
|
|
return Mockito.mock(VMTemplatePoolDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public TemplateDataStoreDao templateDataStoreDao() {
|
|
return Mockito.mock(TemplateDataStoreDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public VMTemplateZoneDao vmTemplateZoneDao() {
|
|
return Mockito.mock(VMTemplateZoneDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public VMInstanceDao vmInstanceDao() {
|
|
return Mockito.mock(VMInstanceDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public PrimaryDataStoreDao primaryDataStoreDao() {
|
|
return Mockito.mock(PrimaryDataStoreDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public StoragePoolHostDao storagePoolHostDao() {
|
|
return Mockito.mock(StoragePoolHostDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public AccountDao accountDao() {
|
|
return Mockito.mock(AccountDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public AgentManager agentMgr() {
|
|
return Mockito.mock(AgentManager.class);
|
|
}
|
|
|
|
@Bean
|
|
public AccountManager accountManager() {
|
|
return Mockito.mock(AccountManager.class);
|
|
}
|
|
|
|
@Bean
|
|
public HostDao hostDao() {
|
|
return Mockito.mock(HostDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public DataCenterDao dcDao() {
|
|
return Mockito.mock(DataCenterDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public UserVmDao userVmDao() {
|
|
return Mockito.mock(UserVmDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public VolumeDao volumeDao() {
|
|
return Mockito.mock(VolumeDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public SnapshotDao snapshotDao() {
|
|
return Mockito.mock(SnapshotDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public ConfigurationDao configDao() {
|
|
return Mockito.mock(ConfigurationDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public DomainDao domainDao() {
|
|
return Mockito.mock(DomainDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public GuestOSDao guestOSDao() {
|
|
return Mockito.mock(GuestOSDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public StorageManager storageManager() {
|
|
return Mockito.mock(StorageManager.class);
|
|
}
|
|
|
|
@Bean
|
|
public UsageEventDao usageEventDao() {
|
|
return Mockito.mock(UsageEventDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public ResourceLimitService resourceLimitMgr() {
|
|
return Mockito.mock(ResourceLimitService.class);
|
|
}
|
|
|
|
@Bean
|
|
public LaunchPermissionDao launchPermissionDao() {
|
|
return Mockito.mock(LaunchPermissionDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public ProjectManager projectMgr() {
|
|
return Mockito.mock(ProjectManager.class);
|
|
}
|
|
|
|
@Bean
|
|
public VolumeDataFactory volFactory() {
|
|
return Mockito.mock(VolumeDataFactory.class);
|
|
}
|
|
|
|
@Bean
|
|
public TemplateDataFactory tmplFactory() {
|
|
return Mockito.mock(TemplateDataFactory.class);
|
|
}
|
|
|
|
@Bean
|
|
public SnapshotDataFactory snapshotFactory() {
|
|
return Mockito.mock(SnapshotDataFactory.class);
|
|
}
|
|
|
|
@Bean
|
|
public TemplateService tmpltSvr() {
|
|
return Mockito.mock(TemplateService.class);
|
|
}
|
|
|
|
@Bean
|
|
public VolumeOrchestrationService volumeMgr() {
|
|
return Mockito.mock(VolumeOrchestrationService.class);
|
|
}
|
|
|
|
@Bean
|
|
public EndPointSelector epSelector() {
|
|
return Mockito.mock(EndPointSelector.class);
|
|
}
|
|
|
|
@Bean
|
|
public UserVmJoinDao userVmJoinDao() {
|
|
return Mockito.mock(UserVmJoinDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public SnapshotDataStoreDao snapshotStoreDao() {
|
|
return Mockito.mock(SnapshotDataStoreDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public ImageStoreDao imageStoreDao() {
|
|
return Mockito.mock(ImageStoreDao.class);
|
|
}
|
|
|
|
@Bean
|
|
public MessageBus messageBus() {
|
|
return Mockito.mock(MessageBus.class);
|
|
}
|
|
|
|
@Bean
|
|
public StorageCacheManager cacheMgr() {
|
|
return Mockito.mock(StorageCacheManager.class);
|
|
}
|
|
|
|
@Bean
|
|
public TemplateAdapter templateAdapter() {
|
|
return Mockito.mock(TemplateAdapter.class);
|
|
}
|
|
|
|
public static class Library implements TypeFilter {
|
|
@Override
|
|
public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
|
|
ComponentScan cs = TestConfiguration.class.getAnnotation(ComponentScan.class);
|
|
return SpringUtils.includedInBasePackageClasses(mdr.getClassMetadata().getClassName(), cs);
|
|
}
|
|
}
|
|
}
|
|
}
|