Idan Shaby has uploaded a new change for review.

Change subject: core: redesign MemoryStorageHandlerTest to use mocks
......................................................................

core: redesign MemoryStorageHandlerTest to use mocks

This patch redesigns the test class of MemoryStorageHandler to use mocks
to make the tests more generic.

Change-Id: Ibe874762dda6967a1bc5e29c973fac7b00fbda70
Bug-Url: https://bugzilla.redhat.com/1186230
Signed-off-by: Idan Shaby <ish...@redhat.com>
---
M 
backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandler.java
M 
backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandlerTest.java
2 files changed, 94 insertions(+), 51 deletions(-)


  git pull ssh://gerrit.ovirt.org:29418/ovirt-engine refs/changes/35/40435/1

diff --git 
a/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandler.java
 
b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandler.java
index c8cb465..20d3912 100644
--- 
a/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandler.java
+++ 
b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandler.java
@@ -54,7 +54,11 @@
         return null;
     }
 
-    private void updateDisksStorage(StorageDomain storageDomain, 
List<DiskImage> disksList) {
+    protected StorageDomainValidator getStorageDomainValidator(StorageDomain 
storageDomain) {
+        return new StorageDomainValidator(storageDomain);
+    }
+
+    protected void updateDisksStorage(StorageDomain storageDomain, 
List<DiskImage> disksList) {
         for (DiskImage disk : disksList) {
             disk.setStorageIds(new 
ArrayList<Guid>(Collections.singletonList(storageDomain.getId())));
         }
@@ -71,7 +75,7 @@
     }
 
     private boolean validateSpaceRequirements(StorageDomain storageDomain, 
List<DiskImage> disksList) {
-        StorageDomainValidator storageDomainValidator = new 
StorageDomainValidator(storageDomain);
+        StorageDomainValidator storageDomainValidator = 
getStorageDomainValidator(storageDomain);
         return (storageDomainValidator.isDomainWithinThresholds().isValid() &&
                 
storageDomainValidator.hasSpaceForClonedDisks(disksList).isValid());
     }
diff --git 
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandlerTest.java
 
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandlerTest.java
index 44dc14e..45c268c 100644
--- 
a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandlerTest.java
+++ 
b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandlerTest.java
@@ -1,78 +1,117 @@
 package org.ovirt.engine.core.bll.memory;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.ovirt.engine.core.utils.MockConfigRule.mockConfig;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyListOf;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
 
 import java.util.Arrays;
+import java.util.LinkedList;
 import java.util.List;
 
-import org.junit.Rule;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.ovirt.engine.core.bll.ValidationResult;
+import org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator;
 import org.ovirt.engine.core.common.businessentities.StorageDomain;
 import org.ovirt.engine.core.common.businessentities.StorageDomainStatus;
 import org.ovirt.engine.core.common.businessentities.StorageDomainType;
 import org.ovirt.engine.core.common.businessentities.storage.DiskImage;
-import org.ovirt.engine.core.common.businessentities.storage.StorageType;
-import org.ovirt.engine.core.common.config.ConfigValues;
-import org.ovirt.engine.core.common.utils.SizeConverter;
+import org.ovirt.engine.core.common.errors.VdcBllMessages;
 import org.ovirt.engine.core.compat.Guid;
-import org.ovirt.engine.core.utils.MockConfigRule;
 
+@RunWith(MockitoJUnitRunner.class)
 public class MemoryStorageHandlerTest {
 
-    public static final long META_DATA_SIZE_IN_GB = 1;
-    public static final Integer LOW_SPACE_IN_GB = 3;
-    public static final Integer ENOUGH_SPACE_IN_GB = 4;
-    public static final Integer THRESHOLD_IN_GB = 4;
-    public static final Integer THRESHOLD_HIGH_GB = 10;
-    public static final int VM_SPACE_IN_MB = 2000;
+    private StorageDomain validStorageDomain;
+    private StorageDomain invalidStorageDomain1;
+    private StorageDomain invalidStorageDomain2;
+    private List<DiskImage> disksList;
 
-    @Rule
-    public MockConfigRule mcr = new MockConfigRule(
-            mockConfig(ConfigValues.FreeSpaceCriticalLowInGB, 
THRESHOLD_IN_GB));
+    @Mock
+    private StorageDomainValidator validStorageDomainValidator;
+
+    @Mock
+    private StorageDomainValidator invalidStorageDomainValidator;
+
+    @Spy
+    private MemoryStorageHandler memoryStorageHandler = 
MemoryStorageHandler.getInstance();
+
+    @Before
+    public void setUp() {
+        disksList = new LinkedList<>();
+        initStorageDomains();
+        initStorageDomainValidators();
+        initMemoryStorageHandler();
+    }
 
     @Test
-    public void verifyDomainForMemory() {
-        Guid sdId = Guid.newGuid();
-        List<StorageDomain> storageDomains = createStorageDomains(sdId);
-        long vmSpaceInBytes = SizeConverter.convert(VM_SPACE_IN_MB,
-                SizeConverter.SizeUnit.MB,
-                SizeConverter.SizeUnit.BYTES).intValue();
-        List<DiskImage> disksList =  
MemoryUtils.createDiskDummies(vmSpaceInBytes, META_DATA_SIZE_IN_GB);
-
-        StorageDomain storageDomain = 
MemoryStorageHandler.getInstance().findStorageDomainForMemory(
-                storageDomains, disksList);
-        assertThat(storageDomain, notNullValue());
-        if (storageDomain != null) {
-            Guid selectedId = storageDomain.getId();
-            assertThat(selectedId.equals(sdId), is(true));
-        }
-
-        mcr.mockConfigValue(ConfigValues.FreeSpaceCriticalLowInGB, 
THRESHOLD_HIGH_GB);
-
-        storageDomain = 
MemoryStorageHandler.getInstance().findStorageDomainForMemory(storageDomains, 
disksList);
-        assertThat(storageDomain, nullValue());
+    public void verifyLastDomainForMemory() {
+        verifyDomainForMemory(Arrays.asList(invalidStorageDomain1, 
invalidStorageDomain2, validStorageDomain));
     }
 
-    private static List<StorageDomain> createStorageDomains(Guid 
sdIdToBeSelected) {
-        StorageDomain sd1 = createStorageDomain(Guid.newGuid(), 
StorageType.NFS, LOW_SPACE_IN_GB);
-        StorageDomain sd2 = createStorageDomain(Guid.newGuid(), 
StorageType.NFS, LOW_SPACE_IN_GB);
-        StorageDomain sd3 = createStorageDomain(sdIdToBeSelected, 
StorageType.NFS, ENOUGH_SPACE_IN_GB);
-        List<StorageDomain> storageDomains = Arrays.asList(sd1, sd2, sd3);
-        return storageDomains;
+    @Test
+    public void verifyNoDomainForMemoryWhenDomainHasLowSpace() {
+        when(validStorageDomainValidator.isDomainWithinThresholds())
+                .thenReturn(new 
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_DISK_SPACE_LOW_ON_STORAGE_DOMAIN));
+        verifyNoDomainForMemory(Arrays.asList(validStorageDomain));
     }
 
-    private static StorageDomain createStorageDomain(Guid guid, StorageType 
storageType, Integer size) {
+    private void initStorageDomains() {
+        validStorageDomain = initStorageDomain();
+        invalidStorageDomain1 = initStorageDomain();
+        invalidStorageDomain2 = initStorageDomain();
+    }
+
+    private StorageDomain initStorageDomain() {
         StorageDomain storageDomain = new StorageDomain();
-        storageDomain.setId(guid);
+        storageDomain.setId(Guid.newGuid());
         storageDomain.setStorageDomainType(StorageDomainType.Data);
-        storageDomain.setStorageType(storageType);
         storageDomain.setStatus(StorageDomainStatus.Active);
-        storageDomain.setAvailableDiskSize(size);
         return storageDomain;
     }
 
+    private void initStorageDomainValidators() {
+        initStorageDomainValidator(validStorageDomainValidator, 
ValidationResult.VALID);
+        initStorageDomainValidator(invalidStorageDomainValidator,
+                new 
ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_DISK_SPACE_LOW_ON_STORAGE_DOMAIN));
+    }
+
+    private void initStorageDomainValidator(StorageDomainValidator 
storageDomainValidator,
+            ValidationResult validationResult) {
+        
when(storageDomainValidator.isDomainWithinThresholds()).thenReturn(validationResult);
+        when(storageDomainValidator.hasSpaceForClonedDisks(disksList))
+                .thenReturn(validationResult);
+    }
+
+    private void initMemoryStorageHandler() {
+        
doNothing().when(memoryStorageHandler).updateDisksStorage(any(StorageDomain.class),
 anyListOf(DiskImage.class));
+
+        doReturn(validStorageDomainValidator)
+                
.when(memoryStorageHandler).getStorageDomainValidator(validStorageDomain);
+
+        doReturn(invalidStorageDomainValidator)
+                
.when(memoryStorageHandler).getStorageDomainValidator(invalidStorageDomain1);
+        doReturn(invalidStorageDomainValidator)
+                
.when(memoryStorageHandler).getStorageDomainValidator(invalidStorageDomain2);
+    }
+
+    private void verifyDomainForMemory(List<StorageDomain> storageDomains) {
+        StorageDomain storageDomain = 
memoryStorageHandler.findStorageDomainForMemory(storageDomains, disksList);
+        assertNotNull(storageDomain);
+        assertEquals(storageDomain, validStorageDomain);
+    }
+
+    private void verifyNoDomainForMemory(List<StorageDomain> storageDomains) {
+        StorageDomain storageDomain = 
memoryStorageHandler.findStorageDomainForMemory(storageDomains, disksList);
+        assertNull(storageDomain);
+    }
 }


-- 
To view, visit https://gerrit.ovirt.org/40435
To unsubscribe, visit https://gerrit.ovirt.org/settings

Gerrit-MessageType: newchange
Gerrit-Change-Id: Ibe874762dda6967a1bc5e29c973fac7b00fbda70
Gerrit-PatchSet: 1
Gerrit-Project: ovirt-engine
Gerrit-Branch: master
Gerrit-Owner: Idan Shaby <ish...@redhat.com>
_______________________________________________
Engine-patches mailing list
Engine-patches@ovirt.org
http://lists.ovirt.org/mailman/listinfo/engine-patches

Reply via email to