Skip to content

Commit 2e3ffde

Browse files
shwstpprshwstppr
committed
add some more tests
Signed-off-by: Abhishek Kumar <[email protected]>
1 parent a4765ba commit 2e3ffde

File tree

4 files changed

+241
-2
lines changed

4 files changed

+241
-2
lines changed

‎engine/schema/src/main/java/com/cloud/host/dao/HostDaoImpl.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1236,7 +1236,7 @@ public List<HostVO> findByClusterId(Long clusterId) {
12361236
return listBy(sc);
12371237
}
12381238

1239-
private List<Long> listIdsBy(Host.Type type, Status status, ResourceState resourceState,
1239+
protected List<Long> listIdsBy(Host.Type type, Status status, ResourceState resourceState,
12401240
HypervisorType hypervisorType, Long zoneId, Long podId, Long clusterId) {
12411241
GenericSearchBuilder<HostVO, Long> sb = createSearchBuilder(Long.class);
12421242
sb.selectFields(sb.entity().getId());
@@ -1708,6 +1708,7 @@ public boolean isHostUp(long hostId) {
17081708
sb.and("id", sb.entity().getId(), Op.EQ);
17091709
sb.selectFields(sb.entity().getStatus());
17101710
SearchCriteria<Status> sc = sb.create();
1711+
sc.setParameters("id", hostId);
17111712
List<Status> statuses = customSearch(sc, null);
17121713
return CollectionUtils.isNotEmpty(statuses) && Status.Up.equals(statuses.get(0));
17131714
}

‎engine/schema/src/test/java/com/cloud/host/dao/HostDaoImplTest.java‎

Lines changed: 184 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,184 @@
1+
// Licensed to the Apache Software Foundation (ASF) under one
2+
// or more contributor license agreements. See the NOTICE file
3+
// distributed with this work for additional information
4+
// regarding copyright ownership. The ASF licenses this file
5+
// to you under the Apache License, Version 2.0 (the
6+
// "License"); you may not use this file except in compliance
7+
// with the License. You may obtain a copy of the License at
8+
//
9+
// http://www.apache.org/licenses/LICENSE-2.0
10+
//
11+
// Unless required by applicable law or agreed to in writing,
12+
// software distributed under the License is distributed on an
13+
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14+
// KIND, either express or implied. See the License for the
15+
// specific language governing permissions and limitations
16+
// under the License.
17+
package com.cloud.host.dao;
18+
19+
import java.util.List;
20+
21+
import org.junit.Assert;
22+
import org.junit.Test;
23+
import org.junit.runner.RunWith;
24+
import org.mockito.Mock;
25+
import org.mockito.Mockito;
26+
import org.mockito.Spy;
27+
import org.mockito.junit.MockitoJUnitRunner;
28+
29+
import com.cloud.host.Host;
30+
import com.cloud.host.HostVO;
31+
import com.cloud.host.Status;
32+
import com.cloud.hypervisor.Hypervisor;
33+
import com.cloud.resource.ResourceState;
34+
import com.cloud.utils.Pair;
35+
import com.cloud.utils.db.GenericDaoBase;
36+
import com.cloud.utils.db.GenericSearchBuilder;
37+
import com.cloud.utils.db.SearchBuilder;
38+
import com.cloud.utils.db.SearchCriteria;
39+
40+
@RunWith(MockitoJUnitRunner.class)
41+
public class HostDaoImplTest {
42+
43+
@Spy
44+
HostDaoImpl hostDao = new HostDaoImpl();
45+
46+
@Mock
47+
private SearchBuilder<HostVO> mockSearchBuilder;
48+
@Mock
49+
private SearchCriteria<HostVO> mockSearchCriteria;
50+
51+
@Test
52+
public void testCountUpAndEnabledHostsInZone() {
53+
long testZoneId = 100L;
54+
hostDao.HostTypeCountSearch = mockSearchBuilder;
55+
Mockito.when(mockSearchBuilder.create()).thenReturn(mockSearchCriteria);
56+
Mockito.doNothing().when(mockSearchCriteria).setParameters(Mockito.anyString(), Mockito.any());
57+
int expected = 5;
58+
Mockito.doReturn(expected).when(hostDao).getCount(mockSearchCriteria);
59+
Integer count = hostDao.countUpAndEnabledHostsInZone(testZoneId);
60+
Assert.assertSame(expected, count);
61+
Mockito.verify(mockSearchCriteria).setParameters("type", Host.Type.Routing);
62+
Mockito.verify(mockSearchCriteria).setParameters("resourceState", ResourceState.Enabled);
63+
Mockito.verify(mockSearchCriteria).setParameters("zoneId", testZoneId);
64+
Mockito.verify(hostDao).getCount(mockSearchCriteria);
65+
}
66+
67+
@Test
68+
public void testCountAllHostsAndCPUSocketsByType() {
69+
Host.Type type = Host.Type.Routing;
70+
GenericDaoBase.SumCount mockSumCount = new GenericDaoBase.SumCount();
71+
mockSumCount.count = 10;
72+
mockSumCount.sum = 20;
73+
HostVO host = Mockito.mock(HostVO.class);
74+
GenericSearchBuilder<HostVO, GenericDaoBase.SumCount> sb = Mockito.mock(GenericSearchBuilder.class);
75+
Mockito.when(sb.entity()).thenReturn(host);
76+
Mockito.doReturn(sb).when(hostDao).createSearchBuilder(GenericDaoBase.SumCount.class);
77+
SearchCriteria<GenericDaoBase.SumCount> sc = Mockito.mock(SearchCriteria.class);
78+
Mockito.when(sb.create()).thenReturn(sc);
79+
Mockito.doReturn(List.of(mockSumCount)).when(hostDao).customSearch(Mockito.any(SearchCriteria.class), Mockito.any());
80+
Pair<Integer, Integer> result = hostDao.countAllHostsAndCPUSocketsByType(type);
81+
Assert.assertEquals(10, result.first().intValue());
82+
Assert.assertEquals(20, result.second().intValue());
83+
Mockito.verify(sc).setParameters("type", type);
84+
}
85+
86+
@Test
87+
public void testIsHostUp() {
88+
long testHostId = 101L;
89+
List<Status> statuses = List.of(Status.Up);
90+
HostVO host = Mockito.mock(HostVO.class);
91+
GenericSearchBuilder<HostVO, Status> sb = Mockito.mock(GenericSearchBuilder.class);
92+
Mockito.when(sb.entity()).thenReturn(host);
93+
SearchCriteria<Status> sc = Mockito.mock(SearchCriteria.class);
94+
Mockito.when(sb.create()).thenReturn(sc);
95+
Mockito.doReturn(sb).when(hostDao).createSearchBuilder(Status.class);
96+
Mockito.doReturn(statuses).when(hostDao).customSearch(Mockito.any(SearchCriteria.class), Mockito.any());
97+
boolean result = hostDao.isHostUp(testHostId);
98+
Assert.assertTrue("Host should be up", result);
99+
Mockito.verify(sc).setParameters("id", testHostId);
100+
Mockito.verify(hostDao).customSearch(sc, null);
101+
}
102+
103+
@Test
104+
public void testFindHostIdsByZoneClusterResourceStateTypeAndHypervisorType() {
105+
Long zoneId = 1L;
106+
Long clusterId = 2L;
107+
List<ResourceState> resourceStates = List.of(ResourceState.Enabled);
108+
List<Host.Type> types = List.of(Host.Type.Routing);
109+
List<Hypervisor.HypervisorType> hypervisorTypes = List.of(Hypervisor.HypervisorType.KVM);
110+
List<Long> mockResults = List.of(1001L, 1002L); // Mocked result
111+
HostVO host = Mockito.mock(HostVO.class);
112+
GenericSearchBuilder<HostVO, Long> sb = Mockito.mock(GenericSearchBuilder.class);
113+
Mockito.when(sb.entity()).thenReturn(host);
114+
SearchCriteria<Long> sc = Mockito.mock(SearchCriteria.class);
115+
Mockito.when(sb.create()).thenReturn(sc);
116+
Mockito.when(sb.and()).thenReturn(sb);
117+
Mockito.doReturn(sb).when(hostDao).createSearchBuilder(Long.class);
118+
Mockito.doReturn(mockResults).when(hostDao).customSearch(Mockito.any(SearchCriteria.class), Mockito.any());
119+
List<Long> hostIds = hostDao.findHostIdsByZoneClusterResourceStateTypeAndHypervisorType(
120+
zoneId, clusterId, resourceStates, types, hypervisorTypes);
121+
Assert.assertEquals(mockResults, hostIds);
122+
Mockito.verify(sc).setParameters("zoneId", zoneId);
123+
Mockito.verify(sc).setParameters("clusterId", clusterId);
124+
Mockito.verify(sc).setParameters("resourceState", resourceStates.toArray());
125+
Mockito.verify(sc).setParameters("type", types.toArray());
126+
Mockito.verify(sc).setParameters("hypervisorTypes", hypervisorTypes.toArray());
127+
}
128+
129+
@Test
130+
public void testListDistinctHypervisorTypes() {
131+
Long zoneId = 1L;
132+
List<Hypervisor.HypervisorType> mockResults = List.of(Hypervisor.HypervisorType.KVM, Hypervisor.HypervisorType.XenServer);
133+
HostVO host = Mockito.mock(HostVO.class);
134+
GenericSearchBuilder<HostVO, Hypervisor.HypervisorType> sb = Mockito.mock(GenericSearchBuilder.class);
135+
Mockito.when(sb.entity()).thenReturn(host);
136+
SearchCriteria<Hypervisor.HypervisorType> sc = Mockito.mock(SearchCriteria.class);
137+
Mockito.when(sb.create()).thenReturn(sc);
138+
Mockito.doReturn(sb).when(hostDao).createSearchBuilder(Hypervisor.HypervisorType.class);
139+
Mockito.doReturn(mockResults).when(hostDao).customSearch(Mockito.any(SearchCriteria.class), Mockito.any());
140+
List<Hypervisor.HypervisorType> hypervisorTypes = hostDao.listDistinctHypervisorTypes(zoneId);
141+
Assert.assertEquals(mockResults, hypervisorTypes);
142+
Mockito.verify(sc).setParameters("zoneId", zoneId);
143+
Mockito.verify(sc).setParameters("type", Host.Type.Routing);
144+
}
145+
146+
@Test
147+
public void testListByIds() {
148+
List<Long> ids = List.of(101L, 102L);
149+
List<HostVO> mockResults = List.of(Mockito.mock(HostVO.class), Mockito.mock(HostVO.class));
150+
hostDao.IdsSearch = mockSearchBuilder;
151+
Mockito.when(mockSearchBuilder.create()).thenReturn(mockSearchCriteria);
152+
Mockito.doReturn(mockResults).when(hostDao).search(Mockito.any(SearchCriteria.class), Mockito.any());
153+
List<HostVO> hosts = hostDao.listByIds(ids);
154+
Assert.assertEquals(mockResults, hosts);
155+
Mockito.verify(mockSearchCriteria).setParameters("id", ids.toArray());
156+
Mockito.verify(hostDao).search(mockSearchCriteria, null);
157+
}
158+
159+
@Test
160+
public void testListIdsBy() {
161+
Host.Type type = Host.Type.Routing;
162+
Status status = Status.Up;
163+
ResourceState resourceState = ResourceState.Enabled;
164+
Hypervisor.HypervisorType hypervisorType = Hypervisor.HypervisorType.KVM;
165+
Long zoneId = 1L, podId = 2L, clusterId = 3L;
166+
List<Long> mockResults = List.of(1001L, 1002L);
167+
HostVO host = Mockito.mock(HostVO.class);
168+
GenericSearchBuilder<HostVO, Long> sb = Mockito.mock(GenericSearchBuilder.class);
169+
Mockito.when(sb.entity()).thenReturn(host);
170+
SearchCriteria<Long> sc = Mockito.mock(SearchCriteria.class);
171+
Mockito.when(sb.create()).thenReturn(sc);
172+
Mockito.doReturn(sb).when(hostDao).createSearchBuilder(Long.class);
173+
Mockito.doReturn(mockResults).when(hostDao).customSearch(Mockito.any(SearchCriteria.class), Mockito.any());
174+
List<Long> hostIds = hostDao.listIdsBy(type, status, resourceState, hypervisorType, zoneId, podId, clusterId);
175+
Assert.assertEquals(mockResults, hostIds);
176+
Mockito.verify(sc).setParameters("type", type);
177+
Mockito.verify(sc).setParameters("status", status);
178+
Mockito.verify(sc).setParameters("resourceState", resourceState);
179+
Mockito.verify(sc).setParameters("hypervisorType", hypervisorType);
180+
Mockito.verify(sc).setParameters("zoneId", zoneId);
181+
Mockito.verify(sc).setParameters("podId", podId);
182+
Mockito.verify(sc).setParameters("clusterId", clusterId);
183+
}
184+
}

‎server/src/main/java/com/cloud/alert/AlertManagerImpl.java‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -259,8 +259,10 @@ public void sendAlert(AlertType alertType, long dataCenterId, Long podId, String
259259
}
260260
}
261261

262+
/**
263+
* Recalculates the capacities of hosts, including CPU and RAM.
264+
*/
262265
protected void recalculateHostCapacities() {
263-
// Calculate CPU and RAM capacities
264266
List<Long> hostIds = hostDao.listIdsByType(Host.Type.Routing);
265267
if (hostIds.isEmpty()) {
266268
return;

‎server/src/test/java/com/cloud/alert/AlertManagerImplTest.java‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,19 +17,34 @@
1717
package com.cloud.alert;
1818

1919
import com.cloud.alert.dao.AlertDao;
20+
import com.cloud.capacity.Capacity;
21+
import com.cloud.capacity.CapacityManager;
22+
import com.cloud.host.Host;
23+
import com.cloud.host.HostVO;
24+
import com.cloud.host.dao.HostDao;
25+
26+
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
27+
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
2028
import org.apache.cloudstack.utils.mailing.SMTPMailSender;
2129
import org.apache.logging.log4j.Logger;
2230
import org.junit.Assert;
2331
import org.junit.Test;
2432
import org.junit.runner.RunWith;
2533
import org.mockito.InjectMocks;
2634
import org.mockito.Mock;
35+
import org.mockito.MockedStatic;
2736
import org.mockito.Mockito;
2837
import org.mockito.Spy;
2938
import org.mockito.junit.MockitoJUnitRunner;
3039

3140
import javax.mail.MessagingException;
3241
import java.io.UnsupportedEncodingException;
42+
import java.net.NetworkInterface;
43+
import java.util.List;
44+
import java.util.concurrent.Callable;
45+
import java.util.concurrent.ExecutorService;
46+
import java.util.concurrent.Executors;
47+
import java.util.concurrent.Future;
3348

3449
@RunWith(MockitoJUnitRunner.class)
3550
public class AlertManagerImplTest {
@@ -44,6 +59,15 @@ public class AlertManagerImplTest {
4459
@Mock
4560
AlertVO alertVOMock;
4661

62+
@Mock
63+
HostDao hostDao;
64+
65+
@Mock
66+
PrimaryDataStoreDao primaryDataStoreDao;
67+
68+
@Mock
69+
CapacityManager capacityManager;
70+
4771
@Mock
4872
Logger loggerMock;
4973

@@ -94,4 +118,32 @@ public void sendAlertTestWarnLogging() {
94118
Mockito.verify(alertManagerImplMock.logger, Mockito.times(2)).warn(Mockito.anyString());
95119
Mockito.verify(alertManagerImplMock, Mockito.never()).sendMessage(Mockito.any());
96120
}
121+
122+
@Test
123+
public void testRecalculateHostCapacities() {
124+
List<Long> mockHostIds = List.of(1L, 2L, 3L);
125+
try (MockedStatic<Executors> ignored = Mockito.mockStatic(Executors.class)) {
126+
Mockito.when(hostDao.listIdsByType(Host.Type.Routing)).thenReturn(mockHostIds);
127+
Mockito.when(hostDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(HostVO.class));
128+
ExecutorService executorService = Mockito.mock(ExecutorService.class);
129+
Mockito.when(executorService.submit(Mockito.any(Callable.class))).thenReturn(Mockito.mock(Future.class));
130+
Mockito.when(Executors.newFixedThreadPool(Mockito.anyInt())).thenReturn(executorService);
131+
alertManagerImplMock.recalculateHostCapacities();
132+
Mockito.verify(executorService, Mockito.times(1)).shutdown();
133+
}
134+
}
135+
136+
@Test
137+
public void testRecalculateStorageCapacities() {
138+
List<Long> mockPoolIds = List.of(101L, 102L, 103L);
139+
try (MockedStatic<Executors> ignored = Mockito.mockStatic(Executors.class)) {
140+
Mockito.when(primaryDataStoreDao.listAllIds()).thenReturn(mockPoolIds);
141+
ExecutorService executorService = Mockito.mock(ExecutorService.class);
142+
Mockito.when(executorService.submit(Mockito.any(Callable.class))).thenReturn(Mockito.mock(Future.class));
143+
Mockito.when(Executors.newFixedThreadPool(Mockito.anyInt())).thenReturn(executorService);
144+
alertManagerImplMock.recalculateStorageCapacities();
145+
Mockito.verify(executorService, Mockito.times(1)).shutdown();
146+
}
147+
}
148+
97149
}

0 commit comments

Comments
 (0)