add unit tests to increase code coverage

Author: sudo87

engine/orchestration/src/test/java/org/apache/cloudstack/engine/orchestration/VolumeOrchestratorTest.java

@@ -17,6 +17,7 @@
 package org.apache.cloudstack.engine.orchestration;
 
 import com.cloud.configuration.Resource;
+import com.cloud.deploy.DeploymentClusterPlanner;
 import com.cloud.exception.InvalidParameterValueException;
 import com.cloud.exception.StorageAccessException;
 import com.cloud.host.Host;
@@ -46,7 +47,9 @@
 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.framework.config.ConfigDepot;
 import org.apache.cloudstack.framework.config.ConfigKey;
+import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
 import org.apache.cloudstack.secret.PassphraseVO;
 import org.apache.cloudstack.secret.dao.PassphraseDao;
 import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
@@ -69,7 +72,9 @@
 import java.util.Date;
 import java.util.List;
 
+import static org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService.VolumeAllocationAlgorithm;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 @RunWith(MockitoJUnitRunner.class)
 public class VolumeOrchestratorTest {
@@ -96,20 +101,22 @@ public class VolumeOrchestratorTest {
     protected DiskOfferingDao diskOfferingDao;
     @Mock
     protected CallContext mockCallContext;
+    @Mock
+    ConfigDepot configDepot;
+    @Mock
+    ConfigurationDao configurationDao;
+
 
     @Spy
     @InjectMocks
     private VolumeOrchestrator volumeOrchestrator = new VolumeOrchestrator();
 
+
     private static final Long DEFAULT_ACCOUNT_PS_RESOURCE_COUNT = 100L;
     private Long accountPSResourceCount;
-    private static final long MOCK_VOLUME_ID = 101L;
     private static final long MOCK_VM_ID = 202L;
     private static final long MOCK_POOL_ID = 303L;
-    private static final long MOCK_DISK_OFFERING_ID = 404L;
-    private static final long MOCK_ACCOUNT_ID = 505L;
     private static final String MOCK_VM_NAME = "Test-VM";
-    private static final String MOCK_VOLUME_UUID = "vol-uuid-123";
 
     @Before
     public void setUp() throws Exception {
@@ -375,7 +382,7 @@ public void testVolumeOnSharedStoragePoolTrue() {
         Mockito.when(pool.getScope()).thenReturn(ScopeType.CLUSTER); // Shared scope
         Mockito.when(storagePoolDao.findById(MOCK_POOL_ID)).thenReturn(pool);
 
-        Assert.assertTrue(volumeOrchestrator.volumeOnSharedStoragePool(volume));
+        assertTrue(volumeOrchestrator.volumeOnSharedStoragePool(volume));
     }
 
     @Test
@@ -414,7 +421,7 @@ public void testVolumeOnSharedStoragePoolFalsePoolNotFound() {
     public void testVolumeInactiveNoVmId() {
         VolumeVO volume = Mockito.mock(VolumeVO.class);
         Mockito.when(volume.getInstanceId()).thenReturn(null);
-        Assert.assertTrue(volumeOrchestrator.volumeInactive(volume));
+        assertTrue(volumeOrchestrator.volumeInactive(volume));
         Mockito.verify(entityMgr, Mockito.never()).findById(Mockito.eq(UserVm.class), Mockito.anyLong());
     }
 
@@ -423,7 +430,7 @@ public void testVolumeInactiveVmNotFound() {
         VolumeVO volume = Mockito.mock(VolumeVO.class);
         Mockito.when(volume.getInstanceId()).thenReturn(MOCK_VM_ID);
         Mockito.when(entityMgr.findById(UserVm.class, MOCK_VM_ID)).thenReturn(null);
-        Assert.assertTrue(volumeOrchestrator.volumeInactive(volume));
+        assertTrue(volumeOrchestrator.volumeInactive(volume));
     }
 
     @Test
@@ -433,7 +440,7 @@ public void testVolumeInactiveVmStopped() {
         UserVm vm = Mockito.mock(UserVm.class);
         Mockito.when(vm.getState()).thenReturn(VirtualMachine.State.Stopped);
         Mockito.when(entityMgr.findById(UserVm.class, MOCK_VM_ID)).thenReturn(vm);
-        Assert.assertTrue(volumeOrchestrator.volumeInactive(volume));
+        assertTrue(volumeOrchestrator.volumeInactive(volume));
     }
 
     @Test
@@ -443,7 +450,7 @@ public void testVolumeInactiveVmDestroyed() {
         UserVm vm = Mockito.mock(UserVm.class);
         Mockito.when(vm.getState()).thenReturn(VirtualMachine.State.Destroyed);
         Mockito.when(entityMgr.findById(UserVm.class, MOCK_VM_ID)).thenReturn(vm);
-        Assert.assertTrue(volumeOrchestrator.volumeInactive(volume));
+        assertTrue(volumeOrchestrator.volumeInactive(volume));
     }
 
     @Test
@@ -485,8 +492,8 @@ public void testGetVmNameOnVolumeSuccess() {
     @Test
     public void testValidateVolumeSizeRangeValid() throws Exception {
         overrideDefaultConfigValue(VolumeOrchestrator.MaxVolumeSize, "2000");
-        Assert.assertTrue(volumeOrchestrator.validateVolumeSizeRange(1024 * 1024 * 1024)); // 1 GiB
-        Assert.assertTrue(volumeOrchestrator.validateVolumeSizeRange(2000 * 1024 * 1024 * 1024)); // 2 TiB
+        assertTrue(volumeOrchestrator.validateVolumeSizeRange(1024 * 1024 * 1024)); // 1 GiB
+        assertTrue(volumeOrchestrator.validateVolumeSizeRange(2000 * 1024 * 1024 * 1024)); // 2 TiB
     }
 
     @Test(expected = InvalidParameterValueException.class)
@@ -525,7 +532,7 @@ public void testCanVmRestartOnAnotherServerAllShared() {
         Mockito.when(storagePoolDao.findById(20L)).thenReturn(pool2);
 
 
-        Assert.assertTrue(volumeOrchestrator.canVmRestartOnAnotherServer(MOCK_VM_ID));
+        assertTrue(volumeOrchestrator.canVmRestartOnAnotherServer(MOCK_VM_ID));
     }
 
     @Test
@@ -567,7 +574,7 @@ public void testCanVmRestartOnAnotherServerOneLocalRecreatable() {
         Mockito.when(storagePoolDao.findById(10L)).thenReturn(pool1);
         Mockito.when(storagePoolDao.findById(30L)).thenReturn(pool2);
 
-        Assert.assertTrue("VM restart should be true if local disk is recreatable",
+        assertTrue("VM restart should be true if local disk is recreatable",
                 volumeOrchestrator.canVmRestartOnAnotherServer(MOCK_VM_ID));
     }
 
@@ -576,4 +583,17 @@ private void overrideDefaultConfigValue(final ConfigKey configKey, final String
         f.setAccessible(true);
         f.set(configKey, value);
     }
+
+    @Test
+    public void testStart() throws Exception {
+        Mockito.when(configDepot.isNewConfig(VolumeAllocationAlgorithm)).thenReturn(true);
+        overrideDefaultConfigValue(DeploymentClusterPlanner.VmAllocationAlgorithm, "firstfit");
+        Mockito.when(configurationDao.update(Mockito.anyString(), Mockito.anyString())).thenReturn(true);
+        volumeOrchestrator.start();
+    }
+
+    @Test
+    public void testConfigKeys() {
+        assertTrue(volumeOrchestrator.getConfigKeys().length > 0);
+    }
 }

engine/storage/src/main/java/org/apache/cloudstack/storage/allocator/AbstractStoragePoolAllocator.java

@@ -77,7 +77,7 @@ public abstract class AbstractStoragePoolAllocator extends AdapterBase implement
     @Inject protected PrimaryDataStoreDao storagePoolDao;
     @Inject protected VolumeDao volumeDao;
     @Inject protected ConfigurationDao configDao;
-    @Inject private CapacityDao capacityDao;
+    @Inject protected CapacityDao capacityDao;
     @Inject private ClusterDao clusterDao;
     @Inject private StorageManager storageMgr;
     @Inject private StorageUtil storageUtil;

engine/storage/src/main/java/org/apache/cloudstack/storage/allocator/ZoneWideStoragePoolAllocator.java

@@ -49,7 +49,7 @@ public class ZoneWideStoragePoolAllocator extends AbstractStoragePoolAllocator {
     @Inject
     private DataStoreManager dataStoreMgr;
     @Inject
-    private CapacityDao capacityDao;
+    protected CapacityDao capacityDao;
 
     @Override
     protected List<StoragePool> select(DiskProfile dskCh, VirtualMachineProfile vmProfile, DeploymentPlan plan, ExcludeList avoid, int returnUpTo, boolean bypassStorageTypeCheck, String keyword) {

engine/storage/src/test/java/org/apache/cloudstack/storage/allocator/AbstractStoragePoolAllocatorTest.java

@@ -17,19 +17,20 @@
 package org.apache.cloudstack.storage.allocator;
 
 
+import com.cloud.capacity.Capacity;
+import com.cloud.capacity.dao.CapacityDao;
 import com.cloud.deploy.DeploymentPlan;
 import com.cloud.deploy.DeploymentPlanner;
 import com.cloud.storage.Storage;
 import com.cloud.storage.StoragePool;
 import com.cloud.storage.dao.VolumeDao;
 import com.cloud.user.Account;
+import com.cloud.utils.Pair;
 import com.cloud.vm.DiskProfile;
 import com.cloud.vm.VirtualMachineProfile;
-
 import org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService;
 import org.apache.cloudstack.framework.config.ConfigKey;
 import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
-
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -41,10 +42,15 @@
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -57,6 +63,10 @@ public class AbstractStoragePoolAllocatorTest {
 
     @Mock
     Account account;
+
+    @Mock
+    CapacityDao capacityDao;
+
     private List<StoragePool> pools;
 
     @Mock
@@ -137,6 +147,28 @@ public void reorderRandomPools() {
         Assert.assertTrue(firstchoice.size() > 2);
     }
 
+    @Test
+    public void reorderStoragePoolsBasedOnAlgorithmFirstFitLeastConsumed() throws Exception {
+        overrideDefaultConfigValue(VolumeOrchestrationService.VolumeAllocationAlgorithm, "firstfitleastconsumed");
+        when(plan.getDataCenterId()).thenReturn(1L);
+        when(plan.getClusterId()).thenReturn(1L);
+        StoragePool pool1 = mock(StoragePool.class);
+        StoragePool pool2 = mock(StoragePool.class);
+        when(pool1.getId()).thenReturn(1L);
+        when(pool2.getId()).thenReturn(2L);
+        List<StoragePool> pools = Arrays.asList(pool1, pool2);
+        List<Long> poolIds = Arrays.asList(2L, 1L);
+        Map<Long, Double> hostCapacityMap = new HashMap<>();
+        hostCapacityMap.put(1L, 8.0);
+        hostCapacityMap.put(2L, 8.5);
+        Pair<List<Long>, Map<Long, Double>> poolsOrderedByCapacity = new Pair<>(poolIds, hostCapacityMap);
+
+        allocator.capacityDao = capacityDao;
+        Mockito.when(capacityDao.orderHostsByFreeCapacity(1L, 1L, Capacity.CAPACITY_TYPE_LOCAL_STORAGE)).thenReturn(poolsOrderedByCapacity);
+        List<StoragePool> result = allocator.reorderPoolsByCapacity(plan, pools);
+        assertEquals(Arrays.asList(pool2, pool1), result);
+    }
+
     private void overrideDefaultConfigValue(final ConfigKey configKey, final String value) throws IllegalAccessException, NoSuchFieldException {
         final Field f = ConfigKey.class.getDeclaredField("_defaultValue");
         f.setAccessible(true);

engine/storage/src/test/java/org/apache/cloudstack/storage/allocator/ZoneWideStoragePoolAllocatorTest.java

@@ -0,0 +1,71 @@
+/*
+ * 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 org.apache.cloudstack.storage.allocator;
+
+import com.cloud.capacity.Capacity;
+import com.cloud.capacity.dao.CapacityDao;
+import com.cloud.deploy.DeploymentPlan;
+import com.cloud.storage.Storage;
+import com.cloud.storage.StoragePool;
+import com.cloud.utils.Pair;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ZoneWideStoragePoolAllocatorTest {
+    private ZoneWideStoragePoolAllocator allocator;
+    private DeploymentPlan plan;
+
+    @Before
+    public void setUp() {
+        allocator = new ZoneWideStoragePoolAllocator();
+        plan = mock(DeploymentPlan.class);
+    }
+
+    @Test
+    public void testReorderPoolsByCapacity() {
+        when(plan.getDataCenterId()).thenReturn(1L);
+        when(plan.getClusterId()).thenReturn(null);
+        StoragePool pool1 = mock(StoragePool.class);
+        StoragePool pool2 = mock(StoragePool.class);
+        when(pool1.getPoolType()).thenReturn(Storage.StoragePoolType.Filesystem);
+        when(pool1.getId()).thenReturn(1L);
+        when(pool2.getId()).thenReturn(2L);
+        List<StoragePool> pools = Arrays.asList(pool1, pool2);
+        List<Long> poolIds = Arrays.asList(2L, 1L);
+        Map<Long, Double> hostCapacityMap = new HashMap<>();
+        hostCapacityMap.put(1L, 8.0);
+        hostCapacityMap.put(2L, 8.5);
+        Pair<List<Long>, Map<Long, Double>> poolsOrderedByCapacity = new Pair<>(poolIds, hostCapacityMap);
+        CapacityDao capacityDao = mock(CapacityDao.class);
+        Mockito.when(capacityDao.orderHostsByFreeCapacity(1L, null, Capacity.CAPACITY_TYPE_LOCAL_STORAGE)).thenReturn(poolsOrderedByCapacity);
+        allocator.capacityDao = capacityDao;
+        List<StoragePool> result = allocator.reorderPoolsByCapacity(plan, pools);
+        assertEquals(Arrays.asList(pool2, pool1), result);
+    }
+}