Skip to content

Commit bbe5e90

Browse files
author
Daan Hoogland
committed
tests
1 parent c584914 commit bbe5e90

3 files changed

Lines changed: 268 additions & 0 deletions

File tree

‎server/src/test/java/com/cloud/resourcelimit/ResourceLimitManagerImplTest.java‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1372,6 +1372,42 @@ public void testUpdateResourceLimitForOwnDomainByDomainAdminThrowsPermissionDeni
13721372
Mockito.verify(resourceLimitDao, Mockito.never()).update(Mockito.anyLong(), Mockito.anyLong());
13731373
}
13741374

1375+
@Test
1376+
public void testUpdateResourceLimitForRootDomainFallsBackToIdWhenDomainNotFound() {
1377+
Long domainId = Domain.ROOT_DOMAIN;
1378+
1379+
when(entityManager.findById(Domain.class, domainId)).thenReturn(null);
1380+
1381+
PermissionDeniedException ex = Assert.assertThrows(PermissionDeniedException.class,
1382+
() -> resourceLimitManager.updateResourceLimit(null, domainId, 8, 20L, null));
1383+
1384+
Assert.assertTrue(ex.getMessage().contains("id " + domainId));
1385+
Mockito.verify(resourceLimitDao, Mockito.never()).update(Mockito.anyLong(), Mockito.anyLong());
1386+
}
1387+
1388+
@Test
1389+
public void testUpdateResourceLimitForOwnDomainByDomainAdminFallsBackToIdWhenDomainNotFound() {
1390+
Long domainId = 2L;
1391+
1392+
when(entityManager.findById(Domain.class, domainId)).thenReturn(null);
1393+
1394+
Account domainAdminAccount = mock(Account.class);
1395+
when(domainAdminAccount.getType()).thenReturn(Account.Type.DOMAIN_ADMIN);
1396+
when(domainAdminAccount.getDomainId()).thenReturn(domainId);
1397+
User user = mock(User.class);
1398+
CallContext.unregister();
1399+
CallContext.register(user, domainAdminAccount);
1400+
1401+
try {
1402+
PermissionDeniedException ex = Assert.assertThrows(PermissionDeniedException.class,
1403+
() -> resourceLimitManager.updateResourceLimit(null, domainId, 8, 20L, null));
1404+
Assert.assertTrue(ex.getMessage().contains("id " + domainId));
1405+
} finally {
1406+
CallContext.unregister();
1407+
}
1408+
Mockito.verify(resourceLimitDao, Mockito.never()).update(Mockito.anyLong(), Mockito.anyLong());
1409+
}
1410+
13751411
@Test
13761412
public void consolidatedResourceLimitsForAllResourceTypesWithAccountId() {
13771413
Long accountId = 1L;

‎server/src/test/java/com/cloud/vm/UserVmManagerImplTest.java‎

Lines changed: 100 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4622,6 +4622,106 @@ public void checkHostsDedicationAlertsIncludeResolvedAccountAndDomainNames() {
46224622
assertTrue(messages.stream().anyMatch(m -> m.contains("domain-a") && m.contains("domain-b")));
46234623
}
46244624

4625+
@Test
4626+
public void checkHostsDedicationAlertNotesDestinationNotDedicatedToSpecificAccount() {
4627+
long srcHostId = 10L;
4628+
long destHostId = 20L;
4629+
long vmId = 1L;
4630+
long serviceOfferingId = 2L;
4631+
4632+
VMInstanceVO vm = Mockito.mock(VMInstanceVO.class);
4633+
when(vm.getId()).thenReturn(vmId);
4634+
when(vm.getDataCenterId()).thenReturn(1L);
4635+
when(vm.getPodIdToDeployIn()).thenReturn(2L);
4636+
when(vm.getServiceOfferingId()).thenReturn(serviceOfferingId);
4637+
4638+
HostVO srcHost = Mockito.mock(HostVO.class);
4639+
when(srcHost.getId()).thenReturn(srcHostId);
4640+
HostVO destHost = Mockito.mock(HostVO.class);
4641+
when(destHost.getId()).thenReturn(destHostId);
4642+
when(hostDao.findById(srcHostId)).thenReturn(srcHost);
4643+
when(hostDao.findById(destHostId)).thenReturn(destHost);
4644+
4645+
// src host is dedicated to an account; dest host is dedicated to a whole domain (no account), so
4646+
// destAccountId resolves to null even though destHost is explicitly dedicated.
4647+
DedicatedResourceVO srcDedication = Mockito.mock(DedicatedResourceVO.class);
4648+
when(srcDedication.getAccountId()).thenReturn(100L);
4649+
when(srcDedication.getDomainId()).thenReturn((Long) null);
4650+
DedicatedResourceVO destDedication = Mockito.mock(DedicatedResourceVO.class);
4651+
when(destDedication.getAccountId()).thenReturn((Long) null);
4652+
when(destDedication.getDomainId()).thenReturn(400L);
4653+
when(dedicatedResourceDao.findByHostId(srcHostId)).thenReturn(srcDedication);
4654+
when(dedicatedResourceDao.findByHostId(destHostId)).thenReturn(destDedication);
4655+
4656+
AccountVO srcAccount = Mockito.mock(AccountVO.class);
4657+
when(srcAccount.toString()).thenReturn("Account {accountName=account-a}");
4658+
when(accountDao.findById(100L)).thenReturn(srcAccount);
4659+
4660+
ServiceOfferingVO serviceOffering = Mockito.mock(ServiceOfferingVO.class);
4661+
when(serviceOffering.getDeploymentPlanner()).thenReturn(null);
4662+
when(_serviceOfferingDao.findById(vmId, serviceOfferingId)).thenReturn(serviceOffering);
4663+
4664+
when(plannerHostReservationDao.listAllDedicatedHosts()).thenReturn(new ArrayList<>());
4665+
4666+
userVmManagerImpl.checkHostsDedication(vm, srcHostId, destHostId);
4667+
4668+
ArgumentCaptor<String> bodyCaptor = ArgumentCaptor.forClass(String.class);
4669+
Mockito.verify(alertManager, Mockito.times(1)).sendAlert(Mockito.eq(AlertManager.AlertType.ALERT_TYPE_USERVM),
4670+
Mockito.eq(1L), Mockito.eq(2L), Mockito.anyString(), bodyCaptor.capture());
4671+
assertTrue(bodyCaptor.getValue().contains("account-a"));
4672+
assertTrue(bodyCaptor.getValue().contains("not dedicated to a specific account"));
4673+
}
4674+
4675+
@Test
4676+
public void checkHostsDedicationAlertNotesDestinationNotDedicatedToSpecificDomain() {
4677+
long srcHostId = 10L;
4678+
long destHostId = 20L;
4679+
long vmId = 1L;
4680+
long serviceOfferingId = 2L;
4681+
4682+
VMInstanceVO vm = Mockito.mock(VMInstanceVO.class);
4683+
when(vm.getId()).thenReturn(vmId);
4684+
when(vm.getDataCenterId()).thenReturn(1L);
4685+
when(vm.getPodIdToDeployIn()).thenReturn(2L);
4686+
when(vm.getServiceOfferingId()).thenReturn(serviceOfferingId);
4687+
4688+
HostVO srcHost = Mockito.mock(HostVO.class);
4689+
when(srcHost.getId()).thenReturn(srcHostId);
4690+
HostVO destHost = Mockito.mock(HostVO.class);
4691+
when(destHost.getId()).thenReturn(destHostId);
4692+
when(hostDao.findById(srcHostId)).thenReturn(srcHost);
4693+
when(hostDao.findById(destHostId)).thenReturn(destHost);
4694+
4695+
// src host is dedicated to a whole domain (no account); dest host is dedicated to an account, so
4696+
// destDomainId resolves to null even though destHost is explicitly dedicated.
4697+
DedicatedResourceVO srcDedication = Mockito.mock(DedicatedResourceVO.class);
4698+
when(srcDedication.getAccountId()).thenReturn((Long) null);
4699+
when(srcDedication.getDomainId()).thenReturn(200L);
4700+
DedicatedResourceVO destDedication = Mockito.mock(DedicatedResourceVO.class);
4701+
when(destDedication.getAccountId()).thenReturn(300L);
4702+
when(destDedication.getDomainId()).thenReturn((Long) null);
4703+
when(dedicatedResourceDao.findByHostId(srcHostId)).thenReturn(srcDedication);
4704+
when(dedicatedResourceDao.findByHostId(destHostId)).thenReturn(destDedication);
4705+
4706+
DomainVO srcDomain = Mockito.mock(DomainVO.class);
4707+
when(srcDomain.toString()).thenReturn("Domain {name=domain-a}");
4708+
when(domainDaoMock.findById(200L)).thenReturn(srcDomain);
4709+
4710+
ServiceOfferingVO serviceOffering = Mockito.mock(ServiceOfferingVO.class);
4711+
when(serviceOffering.getDeploymentPlanner()).thenReturn(null);
4712+
when(_serviceOfferingDao.findById(vmId, serviceOfferingId)).thenReturn(serviceOffering);
4713+
4714+
when(plannerHostReservationDao.listAllDedicatedHosts()).thenReturn(new ArrayList<>());
4715+
4716+
userVmManagerImpl.checkHostsDedication(vm, srcHostId, destHostId);
4717+
4718+
ArgumentCaptor<String> bodyCaptor = ArgumentCaptor.forClass(String.class);
4719+
Mockito.verify(alertManager, Mockito.times(1)).sendAlert(Mockito.eq(AlertManager.AlertType.ALERT_TYPE_USERVM),
4720+
Mockito.eq(1L), Mockito.eq(2L), Mockito.anyString(), bodyCaptor.capture());
4721+
assertTrue(bodyCaptor.getValue().contains("domain-a"));
4722+
assertTrue(bodyCaptor.getValue().contains("not dedicated to a specific domain"));
4723+
}
4724+
46254725
private UserVmVO mockStoppedVmForFailedCreation(Long vmId) {
46264726
UserVmVO vm = Mockito.mock(UserVmVO.class);
46274727
when(vm.getState()).thenReturn(VirtualMachine.State.Stopped);

‎server/src/test/java/org/apache/cloudstack/ha/provider/host/HAAbstractHostProviderTest.java‎

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,132 @@
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 org.apache.cloudstack.ha.provider.host;
18+
19+
import static org.junit.Assert.assertTrue;
20+
21+
import org.apache.cloudstack.alert.AlertService;
22+
import org.apache.cloudstack.ha.HAConfig;
23+
import org.apache.cloudstack.ha.provider.HACheckerException;
24+
import org.apache.cloudstack.ha.provider.HAFenceException;
25+
import org.apache.cloudstack.ha.provider.HARecoveryException;
26+
import org.joda.time.DateTime;
27+
import org.junit.Before;
28+
import org.junit.Test;
29+
import org.junit.runner.RunWith;
30+
import org.mockito.ArgumentCaptor;
31+
import org.mockito.Mock;
32+
import org.mockito.Mockito;
33+
import org.mockito.junit.MockitoJUnitRunner;
34+
import org.springframework.test.util.ReflectionTestUtils;
35+
36+
import com.cloud.alert.AlertManager;
37+
import com.cloud.host.Host;
38+
import com.cloud.host.HostVO;
39+
40+
@RunWith(MockitoJUnitRunner.class)
41+
public class HAAbstractHostProviderTest {
42+
43+
@Mock
44+
AlertManager alertManager;
45+
46+
@Mock
47+
HostVO host;
48+
49+
private HAAbstractHostProvider provider;
50+
51+
private static final class TestHAHostProvider extends HAAbstractHostProvider {
52+
@Override
53+
public boolean isEligible(Host r) {
54+
return true;
55+
}
56+
57+
@Override
58+
public boolean isHealthy(Host r) throws HACheckerException {
59+
return true;
60+
}
61+
62+
@Override
63+
public boolean hasActivity(Host r, DateTime afterThis) throws HACheckerException {
64+
return true;
65+
}
66+
67+
@Override
68+
public boolean recover(Host r) throws HARecoveryException {
69+
return true;
70+
}
71+
72+
@Override
73+
public boolean fence(Host r) throws HAFenceException {
74+
return true;
75+
}
76+
77+
@Override
78+
public Object getConfigValue(HAProviderConfig name, Host r) {
79+
return null;
80+
}
81+
}
82+
83+
@Before
84+
public void setup() {
85+
provider = new TestHAHostProvider();
86+
ReflectionTestUtils.setField(provider, "alertManager", alertManager);
87+
88+
Mockito.when(host.getDataCenterId()).thenReturn(1L);
89+
Mockito.when(host.getPodId()).thenReturn(2L);
90+
Mockito.when(host.toString()).thenReturn("Host {id=5, name=cs-kvm06}");
91+
}
92+
93+
@Test
94+
public void sendAlertForFencingStateDescribesHostAndOperation() {
95+
provider.sendAlert(host, HAConfig.HAState.Fencing);
96+
97+
ArgumentCaptor<String> subjectCaptor = ArgumentCaptor.forClass(String.class);
98+
ArgumentCaptor<String> bodyCaptor = ArgumentCaptor.forClass(String.class);
99+
Mockito.verify(alertManager).sendAlert(Mockito.eq(AlertService.AlertType.ALERT_TYPE_HA_ACTION), Mockito.eq(1L), Mockito.eq(2L),
100+
subjectCaptor.capture(), bodyCaptor.capture());
101+
assertTrue(subjectCaptor.getValue().contains("HA Fencing"));
102+
assertTrue(subjectCaptor.getValue().contains("Host {id=5, name=cs-kvm06}"));
103+
assertTrue(bodyCaptor.getValue().contains("HA Fencing has been performed"));
104+
assertTrue(bodyCaptor.getValue().contains("Host {id=5, name=cs-kvm06}"));
105+
}
106+
107+
@Test
108+
public void sendAlertForRecoveringStateDescribesHostAndOperation() {
109+
provider.sendAlert(host, HAConfig.HAState.Recovering);
110+
111+
ArgumentCaptor<String> subjectCaptor = ArgumentCaptor.forClass(String.class);
112+
ArgumentCaptor<String> bodyCaptor = ArgumentCaptor.forClass(String.class);
113+
Mockito.verify(alertManager).sendAlert(Mockito.eq(AlertService.AlertType.ALERT_TYPE_HA_ACTION), Mockito.eq(1L), Mockito.eq(2L),
114+
subjectCaptor.capture(), bodyCaptor.capture());
115+
assertTrue(subjectCaptor.getValue().contains("HA Recovery"));
116+
assertTrue(subjectCaptor.getValue().contains("Host {id=5, name=cs-kvm06}"));
117+
assertTrue(bodyCaptor.getValue().contains("HA Recovery has been performed"));
118+
assertTrue(bodyCaptor.getValue().contains("Host {id=5, name=cs-kvm06}"));
119+
}
120+
121+
@Test
122+
public void sendAlertForOtherStatesUsesGenericSubjectAndBody() {
123+
provider.sendAlert(host, HAConfig.HAState.Available);
124+
125+
ArgumentCaptor<String> subjectCaptor = ArgumentCaptor.forClass(String.class);
126+
ArgumentCaptor<String> bodyCaptor = ArgumentCaptor.forClass(String.class);
127+
Mockito.verify(alertManager).sendAlert(Mockito.eq(AlertService.AlertType.ALERT_TYPE_HA_ACTION), Mockito.eq(1L), Mockito.eq(2L),
128+
subjectCaptor.capture(), bodyCaptor.capture());
129+
assertTrue(subjectCaptor.getValue().equals("HA operation performed for host"));
130+
assertTrue(bodyCaptor.getValue().equals("HA operation performed for host"));
131+
}
132+
}

0 commit comments

Comments
 (0)