Idan Shaby has uploaded a new change for review. Change subject: core: redesign MemoryStorageHandler to use filters ......................................................................
core: redesign MemoryStorageHandler to use filters This patch doesn't change the behavior of MemoryStorageHandler. Instead, it changes the way we select storage domains for memory volumes to use filters. Each filter verifies that every domain meets a specific condition, and removes those who don't from the list of candidates. This way, one can simply add a new filter to the list and add new logic to the domain selection. Change-Id: Iff7094a2351ab0755ff21ba3ccfc4b8bc5cfff6c 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 A backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilter.java A backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilter.java A backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilter.java A backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilter.java M backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/MemoryStorageHandlerTest.java A backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterAbstractTest.java A backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterTest.java A backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilterTest.java A backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilterTest.java A backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilterTest.java 11 files changed, 386 insertions(+), 113 deletions(-) git pull ssh://gerrit.ovirt.org:29418/ovirt-engine refs/changes/37/40437/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 20d3912..7904374 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 @@ -1,12 +1,15 @@ package org.ovirt.engine.core.bll.memory; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; -import org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator; +import org.ovirt.engine.core.bll.memory.storageDomainFilters.StorageDomainFilter; +import org.ovirt.engine.core.bll.memory.storageDomainFilters.StorageDomainSpaceRequirementsFilter; +import org.ovirt.engine.core.bll.memory.storageDomainFilters.StorageDomainStatusFilter; +import org.ovirt.engine.core.bll.memory.storageDomainFilters.StorageDomainTypeFilter; import org.ovirt.engine.core.common.businessentities.StorageDomain; -import org.ovirt.engine.core.common.businessentities.StorageDomainStatus; import org.ovirt.engine.core.common.businessentities.storage.DiskImage; import org.ovirt.engine.core.common.businessentities.storage.StorageType; import org.ovirt.engine.core.common.businessentities.storage.VolumeType; @@ -38,27 +41,14 @@ public StorageDomain findStorageDomainForMemory(Guid storagePoolId, List<DiskImage> disksList) { List<StorageDomain> domainsInPool = DbFacade.getInstance().getStorageDomainDao().getAllForStoragePool(storagePoolId); - return findStorageDomainForMemory(domainsInPool, disksList); - } - - protected StorageDomain findStorageDomainForMemory(List<StorageDomain> domainsInPool, List<DiskImage> disksList) { - for (StorageDomain currDomain : domainsInPool) { - - updateDisksStorage(currDomain, disksList); - if (currDomain.getStorageDomainType().isDataDomain() - && currDomain.getStatus() == StorageDomainStatus.Active - && validateSpaceRequirements(currDomain, disksList)) { - return currDomain; - } + StorageDomain storageDomainForMemory = findStorageDomainForMemory(domainsInPool, disksList); + if (storageDomainForMemory != null) { + updateDisksStorage(storageDomainForMemory, disksList); } - return null; + return storageDomainForMemory; } - protected StorageDomainValidator getStorageDomainValidator(StorageDomain storageDomain) { - return new StorageDomainValidator(storageDomain); - } - - protected void updateDisksStorage(StorageDomain storageDomain, List<DiskImage> disksList) { + public void updateDisksStorage(StorageDomain storageDomain, List<DiskImage> disksList) { for (DiskImage disk : disksList) { disk.setStorageIds(new ArrayList<Guid>(Collections.singletonList(storageDomain.getId()))); } @@ -69,14 +59,26 @@ updateDiskVolumeType(storageDomain.getStorageType(), disksList.get(0)); } + protected StorageDomain findStorageDomainForMemory(List<StorageDomain> domainsInPool, List<DiskImage> disksList) { + domainsInPool = filterStorageDomains(domainsInPool, disksList); + return domainsInPool.isEmpty() ? null : domainsInPool.get(0); + } + + protected List<? extends StorageDomainFilter> getStorageDomainFilters() { + return Arrays.asList(new StorageDomainStatusFilter(), + new StorageDomainTypeFilter(), + new StorageDomainSpaceRequirementsFilter()); + } + + protected List<StorageDomain> filterStorageDomains(List<StorageDomain> domainsInPool, List<DiskImage> disksList) { + for (StorageDomainFilter storageDomainFilter : getStorageDomainFilters()) { + domainsInPool = storageDomainFilter.filterStorageDomains(domainsInPool, disksList); + } + return domainsInPool; + } + private void updateDiskVolumeType(StorageType storageType, DiskImage disk) { VolumeType volumeType = storageType.isFileDomain() ? VolumeType.Sparse : VolumeType.Preallocated; disk.setVolumeType(volumeType); - } - - private boolean validateSpaceRequirements(StorageDomain storageDomain, List<DiskImage> disksList) { - StorageDomainValidator storageDomainValidator = getStorageDomainValidator(storageDomain); - return (storageDomainValidator.isDomainWithinThresholds().isValid() && - storageDomainValidator.hasSpaceForClonedDisks(disksList).isValid()); } } diff --git a/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilter.java b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilter.java new file mode 100644 index 0000000..3be28cc --- /dev/null +++ b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilter.java @@ -0,0 +1,25 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; + +import org.ovirt.engine.core.common.businessentities.StorageDomain; +import org.ovirt.engine.core.common.businessentities.storage.DiskImage; +import org.ovirt.engine.core.utils.linq.Predicate; + +public abstract class StorageDomainFilter { + + public List<StorageDomain> filterStorageDomains(List<StorageDomain> domainsInPool, List<DiskImage> disksList) { + domainsInPool = new LinkedList<>(domainsInPool); + Iterator<StorageDomain> iterator = domainsInPool.iterator(); + while (iterator.hasNext()) { + if (!getPredicate(disksList).eval(iterator.next())) { + iterator.remove(); + } + } + return domainsInPool; + } + + protected abstract Predicate<StorageDomain> getPredicate(final List<DiskImage> disksList); +} diff --git a/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilter.java b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilter.java new file mode 100644 index 0000000..3b7835a --- /dev/null +++ b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilter.java @@ -0,0 +1,33 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import java.util.List; + +import org.ovirt.engine.core.bll.memory.MemoryStorageHandler; +import org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator; +import org.ovirt.engine.core.common.businessentities.StorageDomain; +import org.ovirt.engine.core.common.businessentities.storage.DiskImage; +import org.ovirt.engine.core.utils.linq.Predicate; + +public class StorageDomainSpaceRequirementsFilter extends StorageDomainFilter { + + @Override + protected Predicate<StorageDomain> getPredicate(final List<DiskImage> disksList) { + return new Predicate<StorageDomain>() { + @Override + public boolean eval(StorageDomain storageDomain) { + updateDisksStorage(storageDomain, disksList); + StorageDomainValidator storageDomainValidator = getStorageDomainValidator(storageDomain); + return storageDomainValidator.isDomainWithinThresholds().isValid() && + storageDomainValidator.hasSpaceForClonedDisks(disksList).isValid(); + } + }; + } + + protected void updateDisksStorage(StorageDomain storageDomain, List<DiskImage> disksList) { + MemoryStorageHandler.getInstance().updateDisksStorage(storageDomain, disksList); + } + + protected StorageDomainValidator getStorageDomainValidator(StorageDomain storageDomain) { + return new StorageDomainValidator(storageDomain); + } +} diff --git a/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilter.java b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilter.java new file mode 100644 index 0000000..9d6df7a --- /dev/null +++ b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilter.java @@ -0,0 +1,21 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import java.util.List; + +import org.ovirt.engine.core.common.businessentities.StorageDomain; +import org.ovirt.engine.core.common.businessentities.StorageDomainStatus; +import org.ovirt.engine.core.common.businessentities.storage.DiskImage; +import org.ovirt.engine.core.utils.linq.Predicate; + +public class StorageDomainStatusFilter extends StorageDomainFilter { + + @Override + protected Predicate<StorageDomain> getPredicate(final List<DiskImage> disksList) { + return new Predicate<StorageDomain>() { + @Override + public boolean eval(StorageDomain storageDomain) { + return storageDomain.getStatus() == StorageDomainStatus.Active; + } + }; + } +} diff --git a/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilter.java b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilter.java new file mode 100644 index 0000000..9d8331c --- /dev/null +++ b/backend/manager/modules/bll/src/main/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilter.java @@ -0,0 +1,20 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import java.util.List; + +import org.ovirt.engine.core.common.businessentities.StorageDomain; +import org.ovirt.engine.core.common.businessentities.storage.DiskImage; +import org.ovirt.engine.core.utils.linq.Predicate; + +public class StorageDomainTypeFilter extends StorageDomainFilter { + + @Override + protected Predicate<StorageDomain> getPredicate(List<DiskImage> disksList) { + return new Predicate<StorageDomain>() { + @Override + public boolean eval(StorageDomain storageDomain) { + return storageDomain.getStorageDomainType().isDataDomain(); + } + }; + } +} 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 14c3af4..7a8cda2 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,14 +1,7 @@ package org.ovirt.engine.core.bll.memory; 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.anyCollectionOf; -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; @@ -17,17 +10,13 @@ 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.bll.memory.storageDomainFilters.StorageDomainFilter; 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.errors.VdcBllMessages; import org.ovirt.engine.core.compat.Guid; +import org.ovirt.engine.core.utils.linq.Predicate; @RunWith(MockitoJUnitRunner.class) public class MemoryStorageHandlerTest { @@ -35,13 +24,11 @@ private StorageDomain validStorageDomain; private StorageDomain invalidStorageDomain1; private StorageDomain invalidStorageDomain2; + private StorageDomain invalidStorageDomain3; + private StorageDomainFilter filter1; + private StorageDomainFilter filter2; + private StorageDomainFilter filter3; private List<DiskImage> disksList; - - @Mock - private StorageDomainValidator validStorageDomainValidator; - - @Mock - private StorageDomainValidator invalidStorageDomainValidator; @Spy private MemoryStorageHandler memoryStorageHandler = MemoryStorageHandler.getInstance(); @@ -50,106 +37,84 @@ public void setUp() { disksList = new LinkedList<>(); initStorageDomains(); - initStorageDomainValidators(); - initMemoryStorageHandler(); + initFilters(); } @Test - public void verifyFirstDomainForMemory() { - verifyDomainForMemory(Arrays.asList(validStorageDomain, invalidStorageDomain1, invalidStorageDomain2)); + public void filterAllDomainsExceptForTheFirstOne() { + filterAllStorageDomainsExceptOne(Arrays.asList( + validStorageDomain, invalidStorageDomain1, invalidStorageDomain2), validStorageDomain); } @Test - public void verifyMiddleDomainForMemory() { - verifyDomainForMemory(Arrays.asList(invalidStorageDomain1, validStorageDomain, invalidStorageDomain2)); + public void filterAllDomainsExceptForTheSecondOne() { + filterAllStorageDomainsExceptOne(Arrays.asList( + invalidStorageDomain1, validStorageDomain, invalidStorageDomain2), validStorageDomain); } @Test - public void verifyLastDomainForMemory() { - verifyDomainForMemory(Arrays.asList(invalidStorageDomain1, invalidStorageDomain2, validStorageDomain)); + public void filterAllDomainsExceptForTheThirdOne() { + filterAllStorageDomainsExceptOne(Arrays.asList( + invalidStorageDomain1, invalidStorageDomain2, validStorageDomain), validStorageDomain); } @Test - public void verifyNoDomainForMemoryWhenDomainIsNotDataDomain() { - for (StorageDomainType storageDomainType : StorageDomainType.values()) { - if (!storageDomainType.isDataDomain()) { - validStorageDomain.setStorageDomainType(storageDomainType); - verifyNoDomainForMemory(Arrays.asList(validStorageDomain)); - } - } - } - - @Test - public void verifyNoDomainForMemoryWhenDomainIsNotActive() { - for (StorageDomainStatus storageDomainStatus : StorageDomainStatus.values()) { - if (storageDomainStatus != StorageDomainStatus.Active) { - validStorageDomain.setStatus(storageDomainStatus); - verifyNoDomainForMemory(Arrays.asList(validStorageDomain)); - } - } - } - - @Test - public void verifyNoDomainForMemoryWhenDomainHasLowSpace() { - when(validStorageDomainValidator.isDomainWithinThresholds()) - .thenReturn(new ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_DISK_SPACE_LOW_ON_STORAGE_DOMAIN)); - verifyNoDomainForMemory(Arrays.asList(validStorageDomain)); - } - - @Test - public void verifyNoDomainForMemoryWhenDomainHasNoSpaceForClonedDisks() { - when(validStorageDomainValidator.hasSpaceForClonedDisks(anyCollectionOf(DiskImage.class))) - .thenReturn(new ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_DISK_SPACE_LOW_ON_STORAGE_DOMAIN)); - verifyNoDomainForMemory(Arrays.asList(validStorageDomain)); + public void filterAllDomains() { + verifyDomainForMemory(Arrays.asList(invalidStorageDomain1, invalidStorageDomain2, invalidStorageDomain3), null); } private void initStorageDomains() { validStorageDomain = initStorageDomain(); invalidStorageDomain1 = initStorageDomain(); invalidStorageDomain2 = initStorageDomain(); + invalidStorageDomain3 = initStorageDomain(); + } + + private void initFilters() { + filter1 = new StorageDomainRejectingFilter(invalidStorageDomain1); + filter2 = new StorageDomainRejectingFilter(invalidStorageDomain2); + filter3 = new StorageDomainRejectingFilter(invalidStorageDomain3); + + List<StorageDomainFilter> storageDomainFilters = + Arrays.asList(filter1, filter2, filter3); + doReturn(storageDomainFilters).when(memoryStorageHandler).getStorageDomainFilters(); } private StorageDomain initStorageDomain() { StorageDomain storageDomain = new StorageDomain(); storageDomain.setId(Guid.newGuid()); - storageDomain.setStorageDomainType(StorageDomainType.Data); - storageDomain.setStatus(StorageDomainStatus.Active); 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 filterAllStorageDomainsExceptOne(List<StorageDomain> storageDomains, + StorageDomain expectedStorageDomain) { + List<StorageDomain> filteredStorageDomains = + memoryStorageHandler.filterStorageDomains(storageDomains, disksList); + assertEquals(filteredStorageDomains, Arrays.asList(expectedStorageDomain)); } - private void initStorageDomainValidator(StorageDomainValidator storageDomainValidator, - ValidationResult validationResult) { - when(storageDomainValidator.isDomainWithinThresholds()).thenReturn(validationResult); - when(storageDomainValidator.hasSpaceForClonedDisks(disksList)) - .thenReturn(validationResult); + private void verifyDomainForMemory(List<StorageDomain> storageDomains, StorageDomain expectedStorageDomain) { + StorageDomain storageDomain = + memoryStorageHandler.findStorageDomainForMemory(storageDomains, disksList); + assertEquals(expectedStorageDomain, storageDomain); } - private void initMemoryStorageHandler() { - doNothing().when(memoryStorageHandler).updateDisksStorage(any(StorageDomain.class), anyListOf(DiskImage.class)); + private static class StorageDomainRejectingFilter extends StorageDomainFilter { - doReturn(validStorageDomainValidator) - .when(memoryStorageHandler).getStorageDomainValidator(validStorageDomain); + private final StorageDomain sdToReject; - doReturn(invalidStorageDomainValidator) - .when(memoryStorageHandler).getStorageDomainValidator(invalidStorageDomain1); - doReturn(invalidStorageDomainValidator) - .when(memoryStorageHandler).getStorageDomainValidator(invalidStorageDomain2); - } + private StorageDomainRejectingFilter(StorageDomain storageDomainToReject) { + this.sdToReject = storageDomainToReject; + } - 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); + @Override + protected Predicate<StorageDomain> getPredicate(List<DiskImage> disksList) { + return new Predicate<StorageDomain>() { + @Override + public boolean eval(StorageDomain storageDomain) { + return !sdToReject.equals(storageDomain); + } + }; + } } } diff --git a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterAbstractTest.java b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterAbstractTest.java new file mode 100644 index 0000000..d7c0972 --- /dev/null +++ b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterAbstractTest.java @@ -0,0 +1,22 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import java.util.LinkedList; +import java.util.List; + +import org.junit.Before; +import org.ovirt.engine.core.common.businessentities.StorageDomain; +import org.ovirt.engine.core.common.businessentities.storage.DiskImage; +import org.ovirt.engine.core.compat.Guid; + +public class StorageDomainFilterAbstractTest { + + protected StorageDomain storageDomain; + protected List<DiskImage> disksList; + + @Before + public void setUp() { + storageDomain = new StorageDomain(); + storageDomain.setId(Guid.newGuid()); + disksList = new LinkedList<>(); + } +} diff --git a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterTest.java b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterTest.java new file mode 100644 index 0000000..0c04aa9 --- /dev/null +++ b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainFilterTest.java @@ -0,0 +1,51 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.ovirt.engine.core.common.businessentities.StorageDomain; +import org.ovirt.engine.core.common.businessentities.storage.DiskImage; +import org.ovirt.engine.core.utils.linq.Predicate; + +@RunWith(MockitoJUnitRunner.class) +public class StorageDomainFilterTest extends StorageDomainFilterAbstractTest { + + private StorageDomainFilter filter; + + @Mock + private Predicate<StorageDomain> predicate; + + @Test + public void testThatFilterRemovesStorageDomainFromList() { + List<StorageDomain> filteredDomains = filterStorageDomain(true); + assertTrue(filteredDomains.isEmpty()); + } + + @Test + public void testThatFilterDoesntRemoveStorageDomainFromList() { + List<StorageDomain> filteredDomains = filterStorageDomain(false); + assertEquals(filteredDomains, Arrays.asList(storageDomain)); + } + + private List<StorageDomain> filterStorageDomain(boolean removeStorageDomainFromList) { + filter = new StorageDomainFilter() { + @Override + protected Predicate<StorageDomain> getPredicate(List<DiskImage> disksList) { + return predicate; + } + }; + + when(predicate.eval(storageDomain)).thenReturn(!removeStorageDomainFromList); + + List<StorageDomain> storageDomains = Arrays.asList(storageDomain); + return filter.filterStorageDomains(storageDomains, disksList); + } +} diff --git a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilterTest.java b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilterTest.java new file mode 100644 index 0000000..c954753 --- /dev/null +++ b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainSpaceRequirementsFilterTest.java @@ -0,0 +1,69 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +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 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.storage.DiskImage; +import org.ovirt.engine.core.common.errors.VdcBllMessages; + +@RunWith(MockitoJUnitRunner.class) +public class StorageDomainSpaceRequirementsFilterTest extends StorageDomainFilterAbstractTest { + + @Spy + private StorageDomainSpaceRequirementsFilter filter = new StorageDomainSpaceRequirementsFilter(); + + @Mock + private StorageDomainValidator storageDomainValidator; + + @Before + @Override + public void setUp() { + super.setUp(); + initFilter(); + initStorageDomainValidator(); + } + + @Test + public void testStorageDomainForMemoryIsValid() { + assertTrue(filter.getPredicate(disksList).eval(storageDomain)); + } + + @Test + public void testStorageDomainForMemoryIsNotValidWhenItHasLowSpace() { + when(storageDomainValidator.isDomainWithinThresholds()) + .thenReturn(new ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_DISK_SPACE_LOW_ON_STORAGE_DOMAIN)); + assertFalse(filter.getPredicate(disksList).eval(storageDomain)); + } + + @Test + public void testStorageDomainForMemoryIsNotValidWhenItHasNoSpaceForClonedDisks() { + when(storageDomainValidator.hasSpaceForClonedDisks(disksList)) + .thenReturn(new ValidationResult(VdcBllMessages.ACTION_TYPE_FAILED_DISK_SPACE_LOW_ON_STORAGE_DOMAIN)); + assertFalse(filter.getPredicate(disksList).eval(storageDomain)); + } + + private void initFilter() { + doNothing().when(filter).updateDisksStorage(any(StorageDomain.class), anyListOf(DiskImage.class)); + doReturn(storageDomainValidator).when(filter).getStorageDomainValidator(storageDomain); + } + + private void initStorageDomainValidator() { + when(storageDomainValidator.isDomainWithinThresholds()).thenReturn(ValidationResult.VALID); + when(storageDomainValidator.hasSpaceForClonedDisks(disksList)) + .thenReturn(ValidationResult.VALID); + } +} diff --git a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilterTest.java b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilterTest.java new file mode 100644 index 0000000..6039834 --- /dev/null +++ b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainStatusFilterTest.java @@ -0,0 +1,33 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import static org.junit.Assert.assertEquals; + +import org.junit.Before; +import org.junit.experimental.theories.DataPoints; +import org.junit.experimental.theories.Theories; +import org.junit.experimental.theories.Theory; +import org.junit.runner.RunWith; +import org.ovirt.engine.core.common.businessentities.StorageDomainStatus; + +@RunWith(Theories.class) +public class StorageDomainStatusFilterTest extends StorageDomainFilterAbstractTest { + + private StorageDomainStatusFilter filter; + + @Before + @Override + public void setUp() { + super.setUp(); + filter = new StorageDomainStatusFilter(); + } + + @DataPoints + public static StorageDomainStatus[] storageDomainStatuses = StorageDomainStatus.values(); + + @Theory + public void testStorageDomainForMemoryIsValidOnlyForActiveStatus(StorageDomainStatus storageDomainStatus) { + storageDomain.setStatus(storageDomainStatus); + assertEquals(filter.getPredicate(disksList).eval(storageDomain), + storageDomainStatus == StorageDomainStatus.Active); + } +} diff --git a/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilterTest.java b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilterTest.java new file mode 100644 index 0000000..f000dc2 --- /dev/null +++ b/backend/manager/modules/bll/src/test/java/org/ovirt/engine/core/bll/memory/storageDomainFilters/StorageDomainTypeFilterTest.java @@ -0,0 +1,32 @@ +package org.ovirt.engine.core.bll.memory.storageDomainFilters; + +import static org.junit.Assert.assertEquals; + +import org.junit.Before; +import org.junit.experimental.theories.DataPoints; +import org.junit.experimental.theories.Theories; +import org.junit.experimental.theories.Theory; +import org.junit.runner.RunWith; +import org.ovirt.engine.core.common.businessentities.StorageDomainType; + +@RunWith(Theories.class) +public class StorageDomainTypeFilterTest extends StorageDomainFilterAbstractTest { + + private StorageDomainTypeFilter filter; + + @Before + @Override + public void setUp() { + super.setUp(); + filter = new StorageDomainTypeFilter(); + } + + @DataPoints + public static StorageDomainType[] storageDomainTypes = StorageDomainType.values(); + + @Theory + public void testStorageDomainForMemoryIsValidOnlyForDataTypes(StorageDomainType storageDomainType) { + storageDomain.setStorageDomainType(storageDomainType); + assertEquals(filter.getPredicate(disksList).eval(storageDomain), storageDomainType.isDataDomain()); + } +} -- To view, visit https://gerrit.ovirt.org/40437 To unsubscribe, visit https://gerrit.ovirt.org/settings Gerrit-MessageType: newchange Gerrit-Change-Id: Iff7094a2351ab0755ff21ba3ccfc4b8bc5cfff6c 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
