ofri masad has uploaded a new change for review. Change subject: core : QuotaMnager Test - basic structure ......................................................................
core : QuotaMnager Test - basic structure Basic structure to to QuotaManagerTest Change-Id: Ie2ff7377f01fdc9de9edb5650cc796e24a8f65c3 Signed-off-by: Ofri Masad <[email protected]> --- A backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/QuotaManagerTest.java 1 file changed, 427 insertions(+), 0 deletions(-) git pull ssh://gerrit.ovirt.org:29418/ovirt-engine refs/changes/22/8422/1 diff --git a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/QuotaManagerTest.java b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/QuotaManagerTest.java new file mode 100644 index 0000000..d0c1e91 --- /dev/null +++ b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/QuotaManagerTest.java @@ -0,0 +1,427 @@ +package org.ovirt.engine.core.bll; + + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.ovirt.engine.core.bll.quota.QuotaManager; +import org.ovirt.engine.core.common.businessentities.*; +import org.ovirt.engine.core.compat.Guid; +import org.ovirt.engine.core.dao.QuotaDAO; + +import java.util.ArrayList; +import java.util.List; + +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class QuotaManagerTest { + + private static final String STORAGE_QUOTA_GLOBAL_NOT_EXCEEDED = "11"; + private static final String STORAGE_QUOTA_GLOBAL_OVER_THRESHOLD = "12"; + private static final String STORAGE_QUOTA_GLOBAL_IN_GRACE = "13"; + private static final String STORAGE_QUOTA_GLOBAL_OVER_GRACE = "14"; + private static final String STORAGE_QUOTA_SPECIFIC_NOT_EXCEEDED = "15"; + private static final String STORAGE_QUOTA_SPECIFIC_OVER_THRESHOLD = "16"; + private static final String STORAGE_QUOTA_SPECIFIC_IN_GRACE = "17"; + private static final String STORAGE_QUOTA_SPECIFIC_OVER_GRACE = "18"; + + private static final String VCPU_QUOTA_GLOBAL_NOT_EXCEEDED = "21"; + private static final String VCPU_QUOTA_GLOBAL_OVER_THRESHOLD = "22"; + private static final String VCPU_QUOTA_GLOBAL_IN_GRACE = "23"; + private static final String VCPU_QUOTA_GLOBAL_OVER_GRACE = "24"; + private static final String VCPU_QUOTA_SPECIFIC_NOT_EXCEEDED = "25"; + private static final String VCPU_QUOTA_SPECIFIC_OVER_THRESHOLD = "26"; + private static final String VCPU_QUOTA_SPECIFIC_IN_GRACE = "27"; + private static final String VCPU_QUOTA_SPECIFIC_OVER_GRACE = "28"; + + private static final String MEM_QUOTA_GLOBAL_NOT_EXCEEDED = "31"; + private static final String MEM_QUOTA_GLOBAL_OVER_THRESHOLD = "32"; + private static final String MEM_QUOTA_GLOBAL_IN_GRACE = "33"; + private static final String MEM_QUOTA_GLOBAL_OVER_GRACE = "34"; + private static final String MEM_QUOTA_SPECIFIC_NOT_EXCEEDED = "35"; + private static final String MEM_QUOTA_SPECIFIC_OVER_THRESHOLD = "36"; + private static final String MEM_QUOTA_SPECIFIC_IN_GRACE = "37"; + private static final String MEM_QUOTA_SPECIFIC_OVER_GRACE = "38"; + + private static final long UNLIMITED_STORAGE = QuotaStorage.UNLIMITED; + private static final int UNLIMITED_VCPU = QuotaVdsGroup.UNLIMITED_VCPU; + private static final long UNLIMITED_MEM = QuotaVdsGroup.UNLIMITED_MEM; + + @Mock + private QuotaDAO quotaDAO; + + private QuotaManager quotaManager = QuotaManager.getInstance(); + private storage_pool storage_pool = new storage_pool(); + private ArrayList<String> canDoActionMessages = new ArrayList<String>(); + + private boolean dbWasCalled = false; + + + + @Before + public void testSetup() { + mockQuotaDAO(); + setStoragePool(); + } + + private void mockQuotaDAO() { + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_GLOBAL_NOT_EXCEEDED))).thenReturn(mockStorageQuotaGlobalNotExceeded()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_GLOBAL_OVER_THRESHOLD))).thenReturn(mockStorageQuotaGlobalOverThreshold()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_GLOBAL_IN_GRACE))).thenReturn(mockStorageQuotaGlobalInGrace()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_GLOBAL_OVER_GRACE))).thenReturn(mockStorageQuotaGlobalOverGrace()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_SPECIFIC_NOT_EXCEEDED))).thenReturn(mockStorageQuotaSpecificNotExceeded()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_SPECIFIC_OVER_THRESHOLD))).thenReturn(mockStorageQuotaSpecificOverThreshold()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_SPECIFIC_IN_GRACE))).thenReturn(mockStorageQuotaSpecificInGrace()); + when(quotaDAO.getById(new Guid(STORAGE_QUOTA_SPECIFIC_OVER_GRACE))).thenReturn(mockStorageQuotaSpecificOverGrace()); + + when(quotaDAO.getById(new Guid(VCPU_QUOTA_GLOBAL_NOT_EXCEEDED))).thenReturn(mockVCPUQuotaGlobalNotExceeded()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_GLOBAL_OVER_THRESHOLD))).thenReturn(mockVCPUQuotaGlobalOverThreshold()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_GLOBAL_IN_GRACE))).thenReturn(mockVCPUQuotaGlobalInGrace()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_GLOBAL_OVER_GRACE))).thenReturn(mockVCPUQuotaGlobalOverGrace()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_SPECIFIC_NOT_EXCEEDED))).thenReturn(mockVCPUQuotaSpecificNotExceeded()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_SPECIFIC_OVER_THRESHOLD))).thenReturn(mockVCPUQuotaSpecificOverThreshold()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_SPECIFIC_IN_GRACE))).thenReturn(mockVCPUQuotaSpecificInGrace()); + when(quotaDAO.getById(new Guid(VCPU_QUOTA_SPECIFIC_OVER_GRACE))).thenReturn(mockVCPUQuotaSpecificOverGrace()); + + when(quotaDAO.getById(new Guid(MEM_QUOTA_GLOBAL_NOT_EXCEEDED))).thenReturn(mockMemQuotaGlobalNotExceeded()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_GLOBAL_OVER_THRESHOLD))).thenReturn(mockMemQuotaGlobalOverThreshold()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_GLOBAL_IN_GRACE))).thenReturn(mockMemQuotaGlobalInGrace()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_GLOBAL_OVER_GRACE))).thenReturn(mockMemQuotaGlobalOverGrace()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_SPECIFIC_NOT_EXCEEDED))).thenReturn(mockMemQuotaSpecificNotExceeded()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_SPECIFIC_OVER_THRESHOLD))).thenReturn(mockMemQuotaSpecificOverThreshold()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_SPECIFIC_IN_GRACE))).thenReturn(mockMemQuotaSpecificInGrace()); + when(quotaDAO.getById(new Guid(MEM_QUOTA_SPECIFIC_OVER_GRACE))).thenReturn(mockMemQuotaSpecificOverGrace()); + } + + private void setStoragePool() { + storage_pool.setQuotaEnforcementType(QuotaEnforcementTypeEnum.HARD_ENFORCEMENT); + storage_pool.setId(new Guid("11111")); + } + + @Test + public void testValidateAnsEtStorageQuota() throws Exception { + //TODO + } + + @Test + public void testDecreaseStorageQuota() throws Exception { + //TODO + } + + @Test + public void testValidateQuotaForStoragePool() throws Exception { + //TODO + } + + @Test + public void testValidateAndSetClusterQuota() throws Exception { + //TODO + } + + @Test + public void testGetQuotaListFromParameters() throws Exception { + //TODO + } + + @Test + public void testRollbackQuota() throws Exception { + //TODO + } + + @Test + public void testRemoveQuotaFromCache() throws Exception { + //TODO + } + + /** + * Mock a basic quota. + * Only the basic data (Id, name, threshold, grace...) is set. + * @return - basic quota with no limitations + */ + private Quota mockBasicQuota() { + dbWasCalled = true; + + // basic data + Quota quota = new Quota(); + quota.setId(Guid.NewGuid()); + quota.setStoragePoolId(Guid.NewGuid()); + quota.setDescription("My Quota description"); + quota.setQuotaName("My Quota Name"); + quota.setGraceStoragePercentage(120); + quota.setGraceVdsGroupPercentage(120); + quota.setThresholdStoragePercentage(80); + quota.setThresholdVdsGroupPercentage(80); + + // Enforcement type would be taken from the storage_pool and not from this field. + // But in case the storage_pool in null this enforcement will be considered. + quota.setQuotaEnforcementType(QuotaEnforcementTypeEnum.HARD_ENFORCEMENT); + + return quota; + } + + private QuotaStorage getQuotaStorage(long storageSize, double storageSizeUsed){ + QuotaStorage storageQuota = new QuotaStorage(); + storageQuota.setStorageSizeGB(storageSize); + storageQuota.setStorageSizeGBUsage(storageSizeUsed); + return storageQuota; + } + + private List<QuotaStorage> getQuotaStorages(long storageSize, double storageSizeUsed){ + ArrayList<QuotaStorage> quotaStorages = new ArrayList<QuotaStorage>(); + quotaStorages.add(getQuotaStorage(UNLIMITED_STORAGE, 0)); + quotaStorages.add(getQuotaStorage(50,5)); + quotaStorages.add(getQuotaStorage(storageSize, storageSizeUsed)); + return quotaStorages; + } + + private QuotaVdsGroup getQuotaVdsGroup(int vCpu, int vCpuUsed, long mem, long memUsed){ + QuotaVdsGroup vdsGroupQuota = new QuotaVdsGroup(); + vdsGroupQuota.setVirtualCpu(vCpu); + vdsGroupQuota.setVirtualCpuUsage(vCpuUsed); + vdsGroupQuota.setMemSizeMB(mem); + vdsGroupQuota.setMemSizeMBUsage(memUsed); + return vdsGroupQuota; + } + + private List<QuotaVdsGroup> getQuotaVdsGroups(int vCpu, int vCpuUsed, long mem, long memUsed){ + ArrayList<QuotaVdsGroup> quotaVdsGroups = new ArrayList<QuotaVdsGroup>(); + quotaVdsGroups.add(getQuotaVdsGroup(UNLIMITED_VCPU,0,UNLIMITED_MEM,0)); + quotaVdsGroups.add(getQuotaVdsGroup(10,2,1000,100)); + quotaVdsGroups.add(getQuotaVdsGroup(vCpu,vCpuUsed,mem,memUsed)); + return quotaVdsGroups; + } + + /////////////////////// Storage global //////////////////////////// + + /** + * Call by Guid: {@literal STORAGE_QUOTA_GLOBAL_NOT_EXCEEDED} + */ + private Quota mockStorageQuotaGlobalNotExceeded(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaStorage(getQuotaStorage(100,9)); + return quota; + } + + /** + * Call by Guid: {@literal STORAGE_QUOTA_GLOBAL_OVER_THRESHOLD} + */ + private Quota mockStorageQuotaGlobalOverThreshold(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaStorage(getQuotaStorage(100,83)); + return quota; + } + + /** + * Call by Guid: {@literal STORAGE_QUOTA_GLOBAL_IN_GRACE} + */ + private Quota mockStorageQuotaGlobalInGrace(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaStorage(getQuotaStorage(100,104)); + return quota; + } + + /** + * Call by Guid: {@literal STORAGE_QUOTA_GLOBAL_OVER_GRACE} + */ + private Quota mockStorageQuotaGlobalOverGrace(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaStorage(getQuotaStorage(100,127)); + return quota; + } + + /////////////////////// Storage specific //////////////////////////// + + /** + * Call by Guid: {@literal STORAGE_QUOTA_SPECIFIC_NOT_EXCEEDED} + */ + private Quota mockStorageQuotaSpecificNotExceeded(){ + Quota quota = mockBasicQuota(); + quota.setQuotaStorages(getQuotaStorages(100, 73)); + return quota; + } + + /** + * Call by Guid: {@literal STORAGE_QUOTA_SPECIFIC_OVER_THRESHOLD} + */ + private Quota mockStorageQuotaSpecificOverThreshold(){ + Quota quota = mockBasicQuota(); + quota.setQuotaStorages(getQuotaStorages(100, 92)); + return quota; + } + + /** + * Call by Guid: {@literal STORAGE_QUOTA_SPECIFIC_IN_GRACE} + */ + private Quota mockStorageQuotaSpecificInGrace(){ + Quota quota = mockBasicQuota(); + quota.setQuotaStorages(getQuotaStorages(100, 103)); + return quota; + } + + /** + * Call by Guid: {@literal STORAGE_QUOTA_SPECIFIC_OVER_GRACE} + */ + private Quota mockStorageQuotaSpecificOverGrace(){ + Quota quota = mockBasicQuota(); + quota.setQuotaStorages(getQuotaStorages(100, 126)); + return quota; + } + + /////////////////////// VCPU global //////////////////////////// + + + /** + * Call by Guid: {@literal VCPU_QUOTA_GLOBAL_NOT_EXCEEDED} + */ + private Quota mockVCPUQuotaGlobalNotExceeded(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(100,18,UNLIMITED_MEM,0)); + return quota; + } + + /** + * Call by Guid: {@literal VCPU_QUOTA_GLOBAL_OVER_THRESHOLD} + */ + private Quota mockVCPUQuotaGlobalOverThreshold(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(100,92,UNLIMITED_MEM,0)); + return quota; + } + + /** + * Call by Guid: {@literal VCPU_QUOTA_GLOBAL_IN_GRACE} + */ + private Quota mockVCPUQuotaGlobalInGrace(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(100,113,UNLIMITED_MEM,0)); + return quota; + } + + /** + * Call by Guid: {@literal VCPU_QUOTA_GLOBAL_OVER_GRACE} + */ + private Quota mockVCPUQuotaGlobalOverGrace(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(100,132,UNLIMITED_MEM,0)); + return quota; + } + + /////////////////////// VCPU specific //////////////////////////// + + /** + * Call by Guid: {@literal VCPU_QUOTA_SPECIFIC_NOT_EXCEEDED} + */ + private Quota mockVCPUQuotaSpecificNotExceeded(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(100,23,UNLIMITED_MEM,0)); + return quota; + } + + /** + * Call by Guid: {@literal VCPU_QUOTA_SPECIFIC_OVER_THRESHOLD} + */ + private Quota mockVCPUQuotaSpecificOverThreshold(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(100,96,UNLIMITED_MEM,0)); + return quota; + } + + /** + * Call by Guid: {@literal VCPU_QUOTA_SPECIFIC_IN_GRACE} + */ + private Quota mockVCPUQuotaSpecificInGrace(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(100,105,UNLIMITED_MEM,0)); + return quota; + } + + /** + * Call by Guid: {@literal VCPU_QUOTA_SPECIFIC_OVER_GRACE} + */ + private Quota mockVCPUQuotaSpecificOverGrace(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(100,134,UNLIMITED_MEM,0)); + return quota; + } + + /////////////////////// Mem global //////////////////////////// + + /** + * Call by Guid: {@literal MEM_QUOTA_GLOBAL_NOT_EXCEEDED} + */ + private Quota mockMemQuotaGlobalNotExceeded(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(UNLIMITED_VCPU,0,2048,512)); + return quota; + } + + /** + * Call by Guid: {@literal MEM_QUOTA_GLOBAL_OVER_THRESHOLD} + */ + private Quota mockMemQuotaGlobalOverThreshold(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(UNLIMITED_VCPU,0,2048,1900)); + return quota; + } + + /** + * Call by Guid: {@literal MEM_QUOTA_GLOBAL_IN_GRACE} + */ + private Quota mockMemQuotaGlobalInGrace(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(UNLIMITED_VCPU,0,2048,2300)); + return quota; + } + + /** + * Call by Guid: {@literal MEM_QUOTA_GLOBAL_OVER_GRACE} + */ + private Quota mockMemQuotaGlobalOverGrace(){ + Quota quota = mockBasicQuota(); + quota.setGlobalQuotaVdsGroup(getQuotaVdsGroup(UNLIMITED_VCPU,0,2048,3000)); + return quota; + } + + /////////////////////// Mem specific //////////////////////////// + + /** + * Call by Guid: {@literal MEM_QUOTA_SPECIFIC_NOT_EXCEEDED} + */ + private Quota mockMemQuotaSpecificNotExceeded(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(UNLIMITED_VCPU,0,2048,512)); + return quota; + } + + /** + * Call by Guid: {@literal MEM_QUOTA_SPECIFIC_OVER_THRESHOLD} + */ + private Quota mockMemQuotaSpecificOverThreshold(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(UNLIMITED_VCPU,0,2048,2000)); + return quota; + } + + /** + * Call by Guid: {@literal MEM_QUOTA_SPECIFIC_IN_GRACE} + */ + private Quota mockMemQuotaSpecificInGrace(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(UNLIMITED_VCPU,0,2048,2100)); + return quota; + } + + /** + * Call by Guid: {@literal MEM_QUOTA_SPECIFIC_OVER_GRACE} + */ + private Quota mockMemQuotaSpecificOverGrace(){ + Quota quota = mockBasicQuota(); + quota.setQuotaVdsGroups(getQuotaVdsGroups(UNLIMITED_VCPU,0,2048,5000)); + return quota; + } + + +} -- To view, visit http://gerrit.ovirt.org/8422 To unsubscribe, visit http://gerrit.ovirt.org/settings Gerrit-MessageType: newchange Gerrit-Change-Id: Ie2ff7377f01fdc9de9edb5650cc796e24a8f65c3 Gerrit-PatchSet: 1 Gerrit-Project: ovirt-engine Gerrit-Branch: master Gerrit-Owner: ofri masad <[email protected]> _______________________________________________ Engine-patches mailing list [email protected] http://lists.ovirt.org/mailman/listinfo/engine-patches
