etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove powermock from server (#7986)

This commit is contained in:
Vishesh 2023-09-22 17:37:08 +05:30 committed by GitHub
parent 84277e783b
commit e721f3b379
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
152 changed files with 3373 additions and 3757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/src/main/java/com/cloud/network/IpAddressManagerImpl.java
View File

@ -314,7 +314,7 @@ public class IpAddressManagerImpl extends ManagerBase implements IpAddressManage
static Boolean rulesContinueOnErrFlag = true;
private static final ConfigKey<Boolean> SystemVmPublicIpReservationModeStrictness = new ConfigKey<Boolean>("Advanced",
public static final ConfigKey<Boolean> SystemVmPublicIpReservationModeStrictness = new ConfigKey<Boolean>("Advanced",
Boolean.class, "system.vm.public.ip.reservation.mode.strictness", "false",
"If enabled, the use of System VMs public IP reservation is strict, preferred if not.", true, ConfigKey.Scope.Global);

26
server/src/test/java/com/cloud/alert/AlertControlsUnitTest.java
View File

@ -16,17 +16,11 @@
// under the License.
package com.cloud.alert;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
import java.util.Date;
import com.cloud.alert.dao.AlertDao;
import com.cloud.server.ManagementServerImpl;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import junit.framework.TestCase;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
@ -35,10 +29,14 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import com.cloud.alert.dao.AlertDao;
import com.cloud.server.ManagementServerImpl;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import java.util.Date;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
public class AlertControlsUnitTest extends TestCase {
private static final Logger s_logger = Logger.getLogger(AlertControlsUnitTest.class);

8
server/src/test/java/com/cloud/alert/AlertManagerImplTest.java
View File

@ -16,10 +16,7 @@
// under the License.
package com.cloud.alert;
import java.io.UnsupportedEncodingException;
import javax.mail.MessagingException;
import com.cloud.alert.dao.AlertDao;
import org.apache.cloudstack.utils.mailing.SMTPMailSender;
import org.apache.log4j.Logger;
import org.junit.Assert;
@ -31,7 +28,8 @@ import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.alert.dao.AlertDao;
import javax.mail.MessagingException;
import java.io.UnsupportedEncodingException;
@RunWith(MockitoJUnitRunner.class)
public class AlertManagerImplTest {

5
server/src/test/java/com/cloud/alert/MockAlertManagerImpl.java
View File

@ -17,11 +17,10 @@
package com.cloud.alert;
import java.util.Map;
import com.cloud.utils.component.ManagerBase;
import javax.naming.ConfigurationException;
import com.cloud.utils.component.ManagerBase;
import java.util.Map;
public class MockAlertManagerImpl extends ManagerBase implements AlertManager {

10
server/src/test/java/com/cloud/api/APITest.java
View File

@ -16,6 +16,10 @@
// under the License.
package com.cloud.api;
import com.cloud.utils.exception.CloudRuntimeException;
import com.google.gson.Gson;
import org.apache.cloudstack.api.response.SuccessResponse;
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.InputStreamReader;
@ -28,12 +32,6 @@ import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Iterator;
import com.google.gson.Gson;
import org.apache.cloudstack.api.response.SuccessResponse;
import com.cloud.utils.exception.CloudRuntimeException;
/**
* Base class for API Test
*

17
server/src/test/java/com/cloud/api/ApiDispatcherTest.java
View File

@ -17,8 +17,13 @@
package com.cloud.api;
import java.util.HashMap;
import com.cloud.api.dispatch.DispatchChain;
import com.cloud.api.dispatch.DispatchTask;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.ServerApiException;
@ -29,13 +34,7 @@ import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.api.dispatch.DispatchChain;
import com.cloud.api.dispatch.DispatchTask;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import java.util.HashMap;
public class ApiDispatcherTest {
protected static final Long resourceId = 1L;

222
server/src/test/java/com/cloud/api/ApiResponseHelperTest.java
View File

@ -16,40 +16,6 @@
// under the License.
package com.cloud.api;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.UUID;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.api.response.AutoScaleVmGroupResponse;
import org.apache.cloudstack.api.response.AutoScaleVmProfileResponse;
import org.apache.cloudstack.api.response.DirectDownloadCertificateResponse;
import org.apache.cloudstack.api.response.NicSecondaryIpResponse;
import org.apache.cloudstack.api.response.UsageRecordResponse;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.usage.UsageService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.domain.DomainVO;
import com.cloud.network.as.AutoScaleVmGroup;
import com.cloud.network.as.AutoScaleVmGroupVO;
@ -71,8 +37,40 @@ import com.cloud.user.UserVO;
import com.cloud.user.dao.UserDataDao;
import com.cloud.utils.net.Ip;
import com.cloud.vm.NicSecondaryIp;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.api.response.AutoScaleVmGroupResponse;
import org.apache.cloudstack.api.response.AutoScaleVmProfileResponse;
import org.apache.cloudstack.api.response.DirectDownloadCertificateResponse;
import org.apache.cloudstack.api.response.NicSecondaryIpResponse;
import org.apache.cloudstack.api.response.UsageRecordResponse;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.usage.UsageService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(PowerMockRunner.class)
import java.lang.reflect.Field;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ApiResponseHelperTest {
@Mock
@ -155,7 +153,6 @@ public class ApiResponseHelperTest {
}
@Test
@PrepareForTest(ApiDBUtils.class)
public void testUsageRecordResponse(){
//Creating the usageVO object to be passed to the createUsageResponse.
Long zoneId = null;
@ -180,12 +177,13 @@ public class ApiResponseHelperTest {
AccountVO account = new AccountVO();
PowerMockito.mockStatic(ApiDBUtils.class);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(account);
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(domain);
try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(account);
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(domain);
UsageRecordResponse MockResponse = helper.createUsageResponse(usage);
assertEquals("DomainName",MockResponse.getDomainName());
UsageRecordResponse MockResponse = helper.createUsageResponse(usage);
assertEquals("DomainName", MockResponse.getDomainName());
}
}
@Test
@ -259,34 +257,33 @@ public class ApiResponseHelperTest {
}
@Test
@PrepareForTest(ApiDBUtils.class)
public void testAutoScaleVmGroupResponse() {
AutoScaleVmGroupVO vmGroup = new AutoScaleVmGroupVO(1L, 2L, 3L, 4L, "test", 5, 6, 7, 8, new Date(), 9L, AutoScaleVmGroup.State.ENABLED);
PowerMockito.mockStatic(ApiDBUtils.class);
when(ApiDBUtils.findAutoScaleVmProfileById(anyLong())).thenReturn(null);
when(ApiDBUtils.findLoadBalancerById(anyLong())).thenReturn(null);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
when(ApiDBUtils.countAvailableVmsByGroupId(anyLong())).thenReturn(9);
try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
when(ApiDBUtils.findAutoScaleVmProfileById(anyLong())).thenReturn(null);
when(ApiDBUtils.findLoadBalancerById(anyLong())).thenReturn(null);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
when(ApiDBUtils.countAvailableVmsByGroupId(anyLong())).thenReturn(9);
AutoScaleVmGroupResponse response = apiResponseHelper.createAutoScaleVmGroupResponse(vmGroup);
assertEquals("test", response.getName());
assertEquals(5, response.getMinMembers());
assertEquals(6, response.getMaxMembers());
assertEquals(8, response.getInterval());
assertEquals(9, response.getAvailableVirtualMachineCount());
assertEquals(AutoScaleVmGroup.State.ENABLED.toString(), response.getState());
AutoScaleVmGroupResponse response = apiResponseHelper.createAutoScaleVmGroupResponse(vmGroup);
assertEquals("test", response.getName());
assertEquals(5, response.getMinMembers());
assertEquals(6, response.getMaxMembers());
assertEquals(8, response.getInterval());
assertEquals(9, response.getAvailableVirtualMachineCount());
assertEquals(AutoScaleVmGroup.State.ENABLED.toString(), response.getState());
assertNull(response.getNetworkName());
assertNull(response.getLbProvider());
assertNull(response.getPublicIp());
assertNull(response.getPublicPort());
assertNull(response.getPrivatePort());
assertNull(response.getNetworkName());
assertNull(response.getLbProvider());
assertNull(response.getPublicIp());
assertNull(response.getPublicPort());
assertNull(response.getPrivatePort());
}
}
@Test
@PrepareForTest(ApiDBUtils.class)
public void testAutoScaleVmGroupResponseWithNetwork() {
AutoScaleVmGroupVO vmGroup = new AutoScaleVmGroupVO(1L, 2L, 3L, 4L, "test", 5, 6, 7, 8, new Date(), 9L, AutoScaleVmGroup.State.ENABLED);
@ -295,78 +292,79 @@ public class ApiResponseHelperTest {
"testnetwork", "displaytext", "networkdomain", null, 1L, null, null, false, null, false);
IPAddressVO ipAddressVO = new IPAddressVO(new Ip("10.10.10.10"), 1L, 1L, 1L,false);
PowerMockito.mockStatic(ApiDBUtils.class);
when(ApiDBUtils.findAutoScaleVmProfileById(anyLong())).thenReturn(null);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
when(ApiDBUtils.findLoadBalancerById(anyLong())).thenReturn(lb);
try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
when(ApiDBUtils.findAutoScaleVmProfileById(anyLong())).thenReturn(null);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
when(ApiDBUtils.findLoadBalancerById(anyLong())).thenReturn(lb);
when(ApiDBUtils.findNetworkById(anyLong())).thenReturn(network);
when(ntwkSrvcDaoMock.getProviderForServiceInNetwork(anyLong(), any())).thenReturn("VirtualRouter");
when(ApiDBUtils.findIpAddressById(anyLong())).thenReturn(ipAddressVO);
when(ApiDBUtils.findNetworkById(anyLong())).thenReturn(network);
when(ntwkSrvcDaoMock.getProviderForServiceInNetwork(anyLong(), any())).thenReturn("VirtualRouter");
when(ApiDBUtils.findIpAddressById(anyLong())).thenReturn(ipAddressVO);
AutoScaleVmGroupResponse response = apiResponseHelper.createAutoScaleVmGroupResponse(vmGroup);
assertEquals("test", response.getName());
assertEquals(5, response.getMinMembers());
assertEquals(6, response.getMaxMembers());
assertEquals(8, response.getInterval());
assertEquals(AutoScaleVmGroup.State.ENABLED.toString(), response.getState());
AutoScaleVmGroupResponse response = apiResponseHelper.createAutoScaleVmGroupResponse(vmGroup);
assertEquals("test", response.getName());
assertEquals(5, response.getMinMembers());
assertEquals(6, response.getMaxMembers());
assertEquals(8, response.getInterval());
assertEquals(AutoScaleVmGroup.State.ENABLED.toString(), response.getState());
assertEquals("testnetwork", response.getNetworkName());
assertEquals("VirtualRouter", response.getLbProvider());
assertEquals("10.10.10.10", response.getPublicIp());
assertEquals("8080", response.getPublicPort());
assertEquals("8081", response.getPrivatePort());
assertEquals("testnetwork", response.getNetworkName());
assertEquals("VirtualRouter", response.getLbProvider());
assertEquals("10.10.10.10", response.getPublicIp());
assertEquals("8080", response.getPublicPort());
assertEquals("8081", response.getPrivatePort());
}
}
@Test
@PrepareForTest(ApiDBUtils.class)
public void testAutoScaleVmProfileResponse() {
AutoScaleVmProfileVO vmProfile = new AutoScaleVmProfileVO(zoneId, domainId, accountId, serviceOfferingId, templateId, null, null, userdata, null, autoScaleUserId);
vmProfile.setUserDataId(userdataId);
vmProfile.setUserDataDetails(userdataDetails);
PowerMockito.mockStatic(ApiDBUtils.class);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
UserData.UserDataOverridePolicy templatePolicy = UserData.UserDataOverridePolicy.APPEND;
VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class);
when(ApiDBUtils.findTemplateById(anyLong())).thenReturn(templateVO);
when(templateVO.getUserDataOverridePolicy()).thenReturn(templatePolicy);
UserData.UserDataOverridePolicy templatePolicy = UserData.UserDataOverridePolicy.APPEND;
VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class);
when(ApiDBUtils.findTemplateById(anyLong())).thenReturn(templateVO);
when(templateVO.getUserDataOverridePolicy()).thenReturn(templatePolicy);
UserDataVO userDataVO = Mockito.mock(UserDataVO.class);
String userDataUuid = "userDataUuid";
String userDataName = "userDataName";
when(userDataDaoMock.findById(anyLong())).thenReturn(userDataVO);
when(userDataVO.getUuid()).thenReturn(userDataUuid);
when(userDataVO.getName()).thenReturn(userDataName);
UserDataVO userDataVO = Mockito.mock(UserDataVO.class);
String userDataUuid = "userDataUuid";
String userDataName = "userDataName";
when(userDataDaoMock.findById(anyLong())).thenReturn(userDataVO);
when(userDataVO.getUuid()).thenReturn(userDataUuid);
when(userDataVO.getName()).thenReturn(userDataName);
AutoScaleVmProfileResponse response = apiResponseHelper.createAutoScaleVmProfileResponse(vmProfile);
assertEquals(templatePolicy.toString(), response.getUserDataPolicy());
assertEquals(userdata, response.getUserData());
assertEquals(userDataUuid, response.getUserDataId());
assertEquals(userDataName, response.getUserDataName());
assertEquals(userdataDetails, response.getUserDataDetails());
AutoScaleVmProfileResponse response = apiResponseHelper.createAutoScaleVmProfileResponse(vmProfile);
assertEquals(templatePolicy.toString(), response.getUserDataPolicy());
assertEquals(userdata, response.getUserData());
assertEquals(userDataUuid, response.getUserDataId());
assertEquals(userDataName, response.getUserDataName());
assertEquals(userdataDetails, response.getUserDataDetails());
}
}
@Test
@PrepareForTest(ApiDBUtils.class)
public void testAutoScaleVmProfileResponseWithoutUserData() {
AutoScaleVmProfileVO vmProfile = new AutoScaleVmProfileVO(zoneId, domainId, accountId, serviceOfferingId, templateId, null, null, null, null, autoScaleUserId);
PowerMockito.mockStatic(ApiDBUtils.class);
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) {
when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO());
when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO());
VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class);
when(ApiDBUtils.findTemplateById(anyLong())).thenReturn(templateVO);
VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class);
when(ApiDBUtils.findTemplateById(anyLong())).thenReturn(templateVO);
AutoScaleVmProfileResponse response = apiResponseHelper.createAutoScaleVmProfileResponse(vmProfile);
assertNull(response.getUserDataPolicy());
assertNull(response.getUserData());
assertNull(response.getUserDataId());
assertNull(response.getUserDataName());
assertNull(response.getUserDataDetails());
AutoScaleVmProfileResponse response = apiResponseHelper.createAutoScaleVmProfileResponse(vmProfile);
assertNull(response.getUserDataPolicy());
assertNull(response.getUserData());
assertNull(response.getUserDataId());
assertNull(response.getUserDataName());
assertNull(response.getUserDataDetails());
}
}
}

56
server/src/test/java/com/cloud/api/ApiServletTest.java
View File

@ -16,23 +16,17 @@
// under the License.
package com.cloud.api;
import static org.mockito.ArgumentMatchers.nullable;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.URLEncoder;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.cloud.api.auth.ListUserTwoFactorAuthenticatorProvidersCmd;
import com.cloud.api.auth.SetupUserTwoFactorAuthenticationCmd;
import com.cloud.api.auth.ValidateUserTwoFactorAuthenticationCodeCmd;
import com.cloud.server.ManagementServer;
import com.cloud.user.Account;
import com.cloud.user.AccountManagerImpl;
import com.cloud.user.AccountService;
import com.cloud.user.User;
import com.cloud.user.UserAccount;
import com.cloud.utils.HttpUtils;
import com.cloud.vm.UserVmManager;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.api.auth.APIAuthenticationManager;
import org.apache.cloudstack.api.auth.APIAuthenticationType;
@ -46,20 +40,24 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import com.cloud.api.auth.ListUserTwoFactorAuthenticatorProvidersCmd;
import com.cloud.api.auth.SetupUserTwoFactorAuthenticationCmd;
import com.cloud.api.auth.ValidateUserTwoFactorAuthenticationCodeCmd;
import com.cloud.server.ManagementServer;
import com.cloud.user.Account;
import com.cloud.user.AccountManagerImpl;
import com.cloud.user.AccountService;
import com.cloud.user.User;
import com.cloud.user.UserAccount;
import com.cloud.utils.HttpUtils;
import com.cloud.vm.UserVmManager;
import org.mockito.junit.MockitoJUnitRunner;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.URLEncoder;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
import static org.mockito.ArgumentMatchers.nullable;
@RunWith(MockitoJUnitRunner.class)
public class ApiServletTest {

4
server/src/test/java/com/cloud/api/ListPerfTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package com.cloud.api;
import java.util.HashMap;
import org.junit.Before;
import org.junit.Test;
import java.util.HashMap;
/**
* Test fixture to do performance test for list command
* Currently we commented out this test suite since it requires a real MS and Db running.

6
server/src/test/java/com/cloud/api/LoginResponse.java
View File

@ -16,11 +16,9 @@
// under the License.
package com.cloud.api;
import com.google.gson.annotations.SerializedName;
import org.apache.cloudstack.api.BaseResponse;
import com.cloud.serializer.Param;
import com.google.gson.annotations.SerializedName;
import org.apache.cloudstack.api.BaseResponse;
/**
* Login Response object

14
server/src/test/java/com/cloud/api/dispatch/CommandCreationWorkerTest.java
View File

@ -16,25 +16,23 @@
// under the License.
package com.cloud.api.dispatch;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import org.apache.cloudstack.api.BaseAsyncCreateCmd;
import org.apache.cloudstack.context.CallContext;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.apache.cloudstack.api.BaseAsyncCreateCmd;
import com.cloud.exception.ResourceAllocationException;
public class CommandCreationWorkerTest {
@Test

1
server/src/test/java/com/cloud/api/dispatch/DispatchChainFactoryTest.java
View File

@ -17,6 +17,7 @@
package com.cloud.api.dispatch;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class DispatchChainFactoryTest {

35
server/src/test/java/com/cloud/api/dispatch/ParamGenericValidationWorkerTest.java
View File

@ -16,15 +16,15 @@
// under the License.
package com.cloud.api.dispatch;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import org.apache.cloudstack.acl.RoleType;
import org.apache.cloudstack.api.APICommand;
import org.apache.cloudstack.api.ApiConstants;
@ -36,15 +36,14 @@ import org.apache.cloudstack.context.CallContext;
import org.apache.log4j.Logger;
import org.junit.Test;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ParamGenericValidationWorkerTest {

28
server/src/test/java/com/cloud/api/dispatch/ParamProcessWorkerTest.java
View File

@ -18,8 +18,18 @@
*/
package com.cloud.api.dispatch;
import java.util.HashMap;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.User;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.Parameter;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@ -29,19 +39,7 @@ import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.Parameter;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.context.CallContext;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.User;
import java.util.HashMap;
@RunWith(MockitoJUnitRunner.class)
public class ParamProcessWorkerTest {

10
server/src/test/java/com/cloud/api/dispatch/SpecificCmdValidationWorkerTest.java
View File

@ -16,19 +16,17 @@
// under the License.
package com.cloud.api.dispatch;
import com.cloud.exception.ResourceAllocationException;
import org.apache.cloudstack.api.BaseCmd;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.apache.cloudstack.api.BaseCmd;
import com.cloud.exception.ResourceAllocationException;
public class SpecificCmdValidationWorkerTest {
@Test

17
server/src/test/java/com/cloud/api/query/MutualExclusiveIdsManagerBaseTest.java
View File

@ -18,13 +18,8 @@
//
package com.cloud.api.query;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.never;
import java.util.Arrays;
import java.util.List;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.utils.db.SearchCriteria;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -32,8 +27,12 @@ import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.utils.db.SearchCriteria;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.never;
@RunWith(MockitoJUnitRunner.class)
public class MutualExclusiveIdsManagerBaseTest {

71
server/src/test/java/com/cloud/api/query/QueryManagerImplTest.java
View File

@ -17,12 +17,23 @@
package com.cloud.api.query;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import com.cloud.api.query.vo.EventJoinVO;
import com.cloud.event.dao.EventJoinDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.network.Network;
import com.cloud.network.dao.NetworkVO;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.Pair;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.db.Filter;
import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import com.cloud.vm.VirtualMachine;
import org.apache.cloudstack.acl.SecurityChecker;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.api.command.user.event.ListEventsCmd;
@ -35,33 +46,17 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.api.query.vo.EventJoinVO;
import com.cloud.event.dao.EventJoinDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.network.Network;
import com.cloud.network.dao.NetworkVO;
import com.cloud.projects.Project;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.Pair;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.db.Filter;
import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import com.cloud.vm.VirtualMachine;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ComponentContext.class, ViewResponseHelper.class})
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class QueryManagerImplTest {
public static final long USER_ID = 1;
public static final long ACCOUNT_ID = 1;
@ -91,19 +86,12 @@ public class QueryManagerImplTest {
UUID.randomUUID().toString(), User.Source.UNKNOWN);
CallContext.register(user, account);
Mockito.when(accountManager.isRootAdmin(account.getId())).thenReturn(false);
Mockito.doNothing().when(accountManager).buildACLSearchParameters(Mockito.any(Account.class), Mockito.anyLong(), Mockito.anyString(), Mockito.anyLong(), Mockito.anyList(),
Mockito.any(), Mockito.anyBoolean(), Mockito.anyBoolean());
Mockito.doNothing().when(accountManager).buildACLSearchBuilder(Mockito.any(SearchBuilder.class), Mockito.anyLong(), Mockito.anyBoolean(), Mockito.anyList(),
Mockito.any(Project.ListProjectResourcesCriteria.class));
Mockito.doNothing().when(accountManager).buildACLViewSearchCriteria(Mockito.any(), Mockito.anyLong(), Mockito.anyBoolean(), Mockito.anyList(),
Mockito.any(Project.ListProjectResourcesCriteria.class));
final SearchBuilder<EventJoinVO> searchBuilder = Mockito.mock(SearchBuilder.class);
final SearchCriteria<EventJoinVO> searchCriteria = Mockito.mock(SearchCriteria.class);
final EventJoinVO eventJoinVO = Mockito.mock(EventJoinVO.class);
when(searchBuilder.entity()).thenReturn(eventJoinVO);
when(searchBuilder.create()).thenReturn(searchCriteria);
Mockito.when(eventJoinDao.createSearchBuilder()).thenReturn(searchBuilder);
Mockito.when(eventJoinDao.createSearchCriteria()).thenReturn(searchCriteria);
}
private ListEventsCmd setupMockListEventsCmd() {
@ -134,10 +122,11 @@ public class QueryManagerImplTest {
for (EventJoinVO vt : events) {
respList.add(eventJoinDao.newEventResponse(vt));
}
PowerMockito.mockStatic(ViewResponseHelper.class);
Mockito.when(ViewResponseHelper.createEventResponse(Mockito.any())).thenReturn(respList);
ListResponse<EventResponse> result = queryManager.searchForEvents(cmd);
Assert.assertEquals((int) result.getCount(), events.size());
try (MockedStatic<ViewResponseHelper> ignored = Mockito.mockStatic(ViewResponseHelper.class)) {
Mockito.when(ViewResponseHelper.createEventResponse(Mockito.any())).thenReturn(respList);
ListResponse<EventResponse> result = queryManager.searchForEvents(cmd);
Assert.assertEquals((int) result.getCount(), events.size());
}
}
@Test(expected = InvalidParameterValueException.class)

25
server/src/test/java/com/cloud/api/query/dao/GenericDaoBaseWithTagInformationBaseTest.java
View File

@ -16,15 +16,18 @@
// under the License.
package com.cloud.api.query.dao;
import static org.junit.Assert.assertEquals;
import org.apache.cloudstack.api.BaseResponseWithTagInformation;
import org.apache.cloudstack.api.response.ResourceTagResponse;
import org.powermock.api.mockito.PowerMockito;
import com.cloud.api.ApiDBUtils;
import com.cloud.api.query.vo.BaseViewWithTagInformationVO;
import com.cloud.api.query.vo.ResourceTagJoinVO;
import com.cloud.server.ResourceTag.ResourceObjectType;
import org.apache.cloudstack.api.BaseResponseWithTagInformation;
import org.apache.cloudstack.api.response.ResourceTagResponse;
import org.junit.After;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.springframework.test.util.ReflectionTestUtils;
import static org.junit.Assert.assertEquals;
public abstract class GenericDaoBaseWithTagInformationBaseTest<T extends BaseViewWithTagInformationVO,
Z extends BaseResponseWithTagInformation> {
@ -43,10 +46,16 @@ public abstract class GenericDaoBaseWithTagInformationBaseTest<T extends BaseVie
private final static String TAG_ACCOUNT_NAME = "admin";
private final static String RESPONSE_OBJECT_NAME = "tag";
private MockedStatic<ApiDBUtils> apiDBUtilsMocked;
public void prepareSetup(){
PowerMockito.spy(ApiDBUtils.class);
PowerMockito.stub(PowerMockito.method(ApiDBUtils.class, "newResourceTagResponse")).toReturn(getResourceTagResponse());
apiDBUtilsMocked = Mockito.mockStatic(ApiDBUtils.class);
apiDBUtilsMocked.when(ReflectionTestUtils.invokeMethod(ApiDBUtils.class, "newResourceTagResponse", Mockito.any(ResourceTagJoinVO.class), Mockito.anyBoolean())).thenReturn(getResourceTagResponse());
}
@After
public void tearDown(){
apiDBUtilsMocked.close();
}
private ResourceTagResponse getResourceTagResponse(){

26
server/src/test/java/com/cloud/api/query/dao/SecurityGroupJoinDaoImplTest.java
View File

@ -16,13 +16,13 @@
// under the License.
package com.cloud.api.query.dao;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import com.cloud.api.query.vo.SecurityGroupJoinVO;
import com.cloud.network.security.SecurityGroupVMMapVO;
import com.cloud.network.security.dao.SecurityGroupVMMapDao;
import com.cloud.user.Account;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.dao.UserVmDao;
import junit.framework.TestCase;
import org.apache.cloudstack.api.response.SecurityGroupResponse;
import org.junit.Before;
import org.junit.Test;
@ -32,14 +32,12 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.api.query.vo.SecurityGroupJoinVO;
import com.cloud.network.security.SecurityGroupVMMapVO;
import com.cloud.network.security.dao.SecurityGroupVMMapDao;
import com.cloud.user.Account;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.dao.UserVmDao;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import junit.framework.TestCase;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class SecurityGroupJoinDaoImplTest extends TestCase {

22
server/src/test/java/com/cloud/api/query/dao/TemplateJoinDaoImplTest.java
View File

@ -16,28 +16,24 @@
// under the License.
package com.cloud.api.query.dao;
import java.util.Date;
import java.util.Map;
import com.cloud.api.query.vo.TemplateJoinVO;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.storage.Storage;
import com.cloud.template.TemplateManager;
import com.cloud.user.Account;
import org.apache.cloudstack.api.response.TemplateResponse;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.api.ApiDBUtils;
import com.cloud.api.query.vo.TemplateJoinVO;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.storage.Storage;
import com.cloud.template.TemplateManager;
import com.cloud.user.Account;
import java.util.Date;
import java.util.Map;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ApiDBUtils.class)
@RunWith(MockitoJUnitRunner.class)
public class TemplateJoinDaoImplTest extends GenericDaoBaseWithTagInformationBaseTest<TemplateJoinVO, TemplateResponse> {
@InjectMocks

17
server/src/test/java/com/cloud/api/query/dao/UserVmJoinDaoImplTest.java
View File

@ -16,19 +16,16 @@
// under the License.
package com.cloud.api.query.dao;
import com.cloud.api.query.vo.UserVmJoinVO;
import org.apache.cloudstack.api.response.UserVmResponse;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.api.ApiDBUtils;
import com.cloud.api.query.vo.UserVmJoinVO;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ApiDBUtils.class)
@RunWith(MockitoJUnitRunner.class)
public class UserVmJoinDaoImplTest extends GenericDaoBaseWithTagInformationBaseTest<UserVmJoinVO, UserVmResponse> {
@InjectMocks
@ -42,6 +39,12 @@ public class UserVmJoinDaoImplTest extends GenericDaoBaseWithTagInformationBaseT
prepareSetup();
}
@Override
@After
public void tearDown() {
super.tearDown();
}
@Test
public void testUpdateUserVmTagInfo(){
testUpdateTagInformation(_userVmJoinDaoImpl, userVm, userVmResponse);

10
server/src/test/java/com/cloud/api/query/dao/VolumeJoinDaoImplTest.java
View File

@ -16,19 +16,15 @@
// under the License.
package com.cloud.api.query.dao;
import com.cloud.api.query.vo.VolumeJoinVO;
import org.apache.cloudstack.api.response.VolumeResponse;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.api.ApiDBUtils;
import com.cloud.api.query.vo.VolumeJoinVO;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ApiDBUtils.class)
@RunWith(MockitoJUnitRunner.class)
public class VolumeJoinDaoImplTest extends GenericDaoBaseWithTagInformationBaseTest<VolumeJoinVO, VolumeResponse> {
@InjectMocks

17
server/src/test/java/com/cloud/capacity/CapacityManagerTest.java
View File

@ -17,21 +17,20 @@
package com.cloud.capacity;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.Assert;
import org.junit.Test;
import com.cloud.capacity.dao.CapacityDao;
import com.cloud.dc.ClusterDetailsDao;
import com.cloud.dc.ClusterDetailsVO;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.vm.VirtualMachine;
import org.junit.Assert;
import org.junit.Test;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class CapacityManagerTest {
CapacityDao CDao = mock(CapacityDao.class);

60
server/src/test/java/com/cloud/configuration/ConfigurationManagerImplTest.java
View File

@ -16,8 +16,9 @@
// under the License.
package com.cloud.configuration;
import java.util.List;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.storage.StorageManager;
import com.cloud.utils.net.NetUtils;
import org.apache.cloudstack.framework.config.ConfigDepot;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.Assert;
@ -25,18 +26,14 @@ import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.storage.StorageManager;
import com.cloud.utils.net.NetUtils;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(NetUtils.class)
@RunWith(MockitoJUnitRunner.class)
public class ConfigurationManagerImplTest {
@Mock
ConfigDepot configDepot;
@ -61,7 +58,7 @@ public class ConfigurationManagerImplTest {
@Test
public void validateIfStringValueIsInRangeTestValidValuesReturnNull() {
String testVariable = "";
String testVariable;
List<String> methods = List.of("privateip", "hypervisorList", "instanceName", "domainName", "default");
Mockito.doReturn(null).when(configurationManagerImplSpy).validateRangePrivateIp(Mockito.anyString(), Mockito.anyString());
Mockito.doReturn(null).when(configurationManagerImplSpy).validateRangeHypervisorList(Mockito.anyString());
@ -76,7 +73,7 @@ public class ConfigurationManagerImplTest {
@Test
public void validateIfStringValueIsInRangeTestInvalidValuesReturnString() {
String testVariable = "";
String testVariable;
List<String> methods = List.of("privateip", "hypervisorList", "instanceName", "domainName", "default");
Mockito.doReturn("returnMsg").when(configurationManagerImplSpy).validateRangePrivateIp(Mockito.anyString(), Mockito.anyString());
Mockito.doReturn("returnMsg").when(configurationManagerImplSpy).validateRangeHypervisorList(Mockito.anyString());
@ -94,7 +91,6 @@ public class ConfigurationManagerImplTest {
public void validateIfStringValueIsInRangeTestMultipleRangesValidValueReturnNull() {
Mockito.doReturn("returnMsg1").when(configurationManagerImplSpy).validateRangePrivateIp(Mockito.anyString(), Mockito.anyString());
Mockito.doReturn(null).when(configurationManagerImplSpy).validateRangeInstanceName(Mockito.anyString());
Mockito.doReturn("returnMsg2").when(configurationManagerImplSpy).validateRangeOther(Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
String testVariable = configurationManagerImplSpy.validateIfStringValueIsInRange("name", "value", "privateip", "instanceName", "default");
Assert.assertNull(testVariable);
}
@ -111,18 +107,20 @@ public class ConfigurationManagerImplTest {
@Test
public void validateRangePrivateIpTestValidValueReturnNull() {
PowerMockito.mockStatic(NetUtils.class);
PowerMockito.when(NetUtils.isSiteLocalAddress(Mockito.anyString())).thenReturn(true);
String testVariable = configurationManagerImplSpy.validateRangePrivateIp("name", "value");
Assert.assertNull(testVariable);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.isSiteLocalAddress(Mockito.anyString())).thenReturn(true);
String testVariable = configurationManagerImplSpy.validateRangePrivateIp("name", "value");
Assert.assertNull(testVariable);
}
}
@Test
public void validateRangePrivateIpTestInvalidValueReturnString() {
PowerMockito.mockStatic(NetUtils.class);
PowerMockito.when(NetUtils.isSiteLocalAddress(Mockito.anyString())).thenReturn(false);
String testVariable = configurationManagerImplSpy.validateRangePrivateIp("name", "value");
Assert.assertEquals("a valid site local IP address", testVariable);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.isSiteLocalAddress(Mockito.anyString())).thenReturn(false);
String testVariable = configurationManagerImplSpy.validateRangePrivateIp("name", "value");
Assert.assertEquals("a valid site local IP address", testVariable);
}
}
@Test
@ -139,18 +137,20 @@ public class ConfigurationManagerImplTest {
@Test
public void validateRangeInstanceNameTestValidValueReturnNull() {
PowerMockito.mockStatic(NetUtils.class);
PowerMockito.when(NetUtils.verifyInstanceName(Mockito.anyString())).thenReturn(true);
String testVariable = configurationManagerImplSpy.validateRangeInstanceName("ThisStringShouldBeValid");
Assert.assertNull(testVariable);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.verifyInstanceName(Mockito.anyString())).thenReturn(true);
String testVariable = configurationManagerImplSpy.validateRangeInstanceName("ThisStringShouldBeValid");
Assert.assertNull(testVariable);
}
}
@Test
public void validateRangeInstanceNameTestInvalidValueReturnString() {
PowerMockito.mockStatic(NetUtils.class);
PowerMockito.when(NetUtils.verifyInstanceName(Mockito.anyString())).thenReturn(false);
String testVariable = configurationManagerImplSpy.validateRangeInstanceName("This string should not be valid.");
Assert.assertEquals("a valid instance name (instance names cannot contain hyphens, spaces or plus signs)", testVariable);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.verifyInstanceName(Mockito.anyString())).thenReturn(false);
String testVariable = configurationManagerImplSpy.validateRangeInstanceName("This string should not be valid.");
Assert.assertEquals("a valid instance name (instance names cannot contain hyphens, spaces or plus signs)", testVariable);
}
}
@Test
@ -213,8 +213,6 @@ public class ConfigurationManagerImplTest {
configurationManagerImplSpy.validateIpAddressRelatedConfigValues("config.ip", "");
Mockito.when(configurationManagerImplSpy._configDepot.get("config.ip")).thenReturn(null);
configurationManagerImplSpy.validateIpAddressRelatedConfigValues("config.ip", "something");
ConfigKey<?> key = StorageManager.MountDisabledStoragePool;
Mockito.doReturn(key).when(configurationManagerImplSpy._configDepot).get(StorageManager.MountDisabledStoragePool.key());
configurationManagerImplSpy.validateIpAddressRelatedConfigValues(StorageManager.MountDisabledStoragePool.key(), "false");
}

109
server/src/test/java/com/cloud/configuration/ConfigurationManagerTest.java
View File

@ -17,61 +17,6 @@
package com.cloud.configuration;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.UUID;
import org.apache.cloudstack.api.command.admin.network.CreateGuestNetworkIpv6PrefixCmd;
import org.apache.cloudstack.api.command.admin.network.CreateNetworkOfferingCmd;
import org.apache.cloudstack.api.command.admin.network.DeleteGuestNetworkIpv6PrefixCmd;
import org.apache.cloudstack.api.command.admin.network.ListGuestNetworkIpv6PrefixesCmd;
import org.apache.cloudstack.api.command.admin.vlan.CreateVlanIpRangeCmd;
import org.apache.cloudstack.api.command.admin.vlan.DedicatePublicIpRangeCmd;
import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd;
import org.apache.cloudstack.api.command.admin.zone.CreateZoneCmd;
import org.apache.cloudstack.api.command.admin.zone.UpdateZoneCmd;
import org.apache.cloudstack.api.command.user.network.ListNetworkOfferingsCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.engine.subsystem.api.storage.ZoneScope;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBusBase;
import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.stubbing.Answer;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.api.query.dao.NetworkOfferingJoinDao;
import com.cloud.api.query.vo.NetworkOfferingJoinVO;
import com.cloud.configuration.Resource.ResourceType;
@ -132,6 +77,60 @@ import com.cloud.utils.net.Ip;
import com.cloud.utils.net.NetUtils;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.api.command.admin.network.CreateGuestNetworkIpv6PrefixCmd;
import org.apache.cloudstack.api.command.admin.network.CreateNetworkOfferingCmd;
import org.apache.cloudstack.api.command.admin.network.DeleteGuestNetworkIpv6PrefixCmd;
import org.apache.cloudstack.api.command.admin.network.ListGuestNetworkIpv6PrefixesCmd;
import org.apache.cloudstack.api.command.admin.vlan.CreateVlanIpRangeCmd;
import org.apache.cloudstack.api.command.admin.vlan.DedicatePublicIpRangeCmd;
import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd;
import org.apache.cloudstack.api.command.admin.zone.CreateZoneCmd;
import org.apache.cloudstack.api.command.admin.zone.UpdateZoneCmd;
import org.apache.cloudstack.api.command.user.network.ListNetworkOfferingsCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.engine.subsystem.api.storage.ZoneScope;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBusBase;
import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.stubbing.Answer;
import org.springframework.test.util.ReflectionTestUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.UUID;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ConfigurationManagerTest {

17
server/src/test/java/com/cloud/configuration/ValidateIpRangeTest.java
View File

@ -16,21 +16,20 @@
// under the License.
package com.cloud.configuration;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import com.cloud.dc.VlanVO;
import com.cloud.network.Network;
import com.cloud.network.NetworkModel;
import com.cloud.utils.Pair;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import com.cloud.dc.VlanVO;
import com.cloud.network.Network;
import com.cloud.network.NetworkModel;
import com.cloud.utils.Pair;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.Mockito.when;
public class ValidateIpRangeTest {
@Mock

43
server/src/test/java/com/cloud/consoleproxy/ConsoleProxyManagerTest.java
View File

@ -17,30 +17,9 @@
package com.cloud.consoleproxy;
import static org.mockito.AdditionalMatchers.not;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.apache.log4j.Logger;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenter.NetworkType;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.info.ConsoleProxyStatus;
import com.cloud.network.Networks.TrafficType;
@ -52,6 +31,26 @@ import com.cloud.vm.ConsoleProxyVO;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParseException;
import org.apache.log4j.Logger;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.mockito.AdditionalMatchers.not;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ConsoleProxyManagerTest {

108
server/src/test/java/com/cloud/deploy/DeploymentPlanningManagerImplTest.java
View File

@ -16,61 +16,6 @@
// under the License.
package com.cloud.deploy;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import org.apache.cloudstack.affinity.AffinityGroupProcessor;
import org.apache.cloudstack.affinity.AffinityGroupService;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.affinity.dao.AffinityGroupDomainMapDao;
import org.apache.cloudstack.affinity.dao.AffinityGroupVMMapDao;
import org.apache.cloudstack.engine.cloud.entity.api.db.dao.VMReservationDao;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.apache.cloudstack.test.utils.SpringUtils;
import org.apache.commons.collections.CollectionUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.cloud.agent.AgentManager;
import com.cloud.capacity.CapacityManager;
import com.cloud.capacity.dao.CapacityDao;
@ -129,6 +74,59 @@ import com.cloud.vm.VirtualMachineProfileImpl;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.UserVmDetailsDao;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.affinity.AffinityGroupProcessor;
import org.apache.cloudstack.affinity.AffinityGroupService;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.affinity.dao.AffinityGroupDomainMapDao;
import org.apache.cloudstack.affinity.dao.AffinityGroupVMMapDao;
import org.apache.cloudstack.engine.cloud.entity.api.db.dao.VMReservationDao;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.apache.cloudstack.test.utils.SpringUtils;
import org.apache.commons.collections.CollectionUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)

64
server/src/test/java/com/cloud/event/ActionEventInterceptorTest.java
View File

@ -17,16 +17,17 @@
package com.cloud.event;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.inject.Inject;
import com.cloud.configuration.Config;
import com.cloud.event.dao.EventDao;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.user.dao.UserDao;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.context.CallContext;
@ -40,27 +41,22 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.configuration.Config;
import com.cloud.event.dao.EventDao;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.user.dao.UserDao;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import javax.inject.Inject;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ComponentContext.class)
@RunWith(MockitoJUnitRunner.class)
public class ActionEventInterceptorTest {
//Predictable constants used throughout this test.
public static final long EVENT_ID = 1;
@ -108,6 +104,8 @@ public class ActionEventInterceptorTest {
protected static final String eventType = EventTypes.EVENT_VM_START;
protected static final String eventDescription = "Starting VM";
private MockedStatic<ComponentContext> componentContextMocked;
/**
* This setup method injects the mocked beans into the ActionEventUtils class.
* Because ActionEventUtils has static methods, we must also remember these fields
@ -152,7 +150,7 @@ public class ActionEventInterceptorTest {
public void setupCommonMocks() throws Exception {
//Some basic mocks.
Mockito.when(configDao.getValue(Config.PublishActionEvent.key())).thenReturn("true");
PowerMockito.mockStatic(ComponentContext.class);
componentContextMocked = Mockito.mockStatic(ComponentContext.class);
Mockito.when(ComponentContext.getComponent(EventBus.class)).thenReturn(eventBus);
//Needed for persist to actually set an ID that can be returned from the ActionEventUtils
@ -170,22 +168,12 @@ public class ActionEventInterceptorTest {
});
//Needed to record events published on the bus.
Mockito.doAnswer(new Answer<Void>() {
@Override public Void answer(InvocationOnMock invocation) throws Throwable {
Event event = (Event)invocation.getArguments()[0];
publishedEvents.add(event);
return null;
}
}).when(eventBus).publish(Mockito.any(Event.class));
account = new AccountVO("testaccount", 1L, "networkdomain", Account.Type.NORMAL, "uuid");
account.setId(ACCOUNT_ID);
user = new UserVO(1, "testuser", "password", "firstname", "lastName", "email", "timezone",
UUID.randomUUID().toString(), User.Source.UNKNOWN);
Mockito.when(accountDao.findById(ACCOUNT_ID)).thenReturn(account);
Mockito.when(userDao.findById(USER_ID)).thenReturn(user);
}
/**
@ -208,6 +196,8 @@ public class ActionEventInterceptorTest {
}
utils.init();
componentContextMocked.close();
}
@Test

73
server/src/test/java/com/cloud/event/ActionEventUtilsTest.java
View File

@ -16,33 +16,6 @@
// under the License.
package com.cloud.event;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.inject.Inject;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.events.Event;
import org.apache.cloudstack.framework.events.EventBus;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.configuration.Config;
import com.cloud.event.dao.EventDao;
import com.cloud.network.IpAddress;
@ -61,9 +34,32 @@ import com.cloud.vm.VirtualMachine;
import com.cloud.vm.snapshot.VMSnapshot;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.events.Event;
import org.apache.cloudstack.framework.events.EventBus;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ComponentContext.class)
import javax.inject.Inject;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@RunWith(MockitoJUnitRunner.class)
public class ActionEventUtilsTest {
//Predictable constants used throughout this test.
public static final long EVENT_ID = 1;
@ -105,6 +101,8 @@ public class ActionEventUtilsTest {
private AccountVO account;
private UserVO user;
private MockedStatic<ComponentContext> componentContextMocked;
/**
* This setup method injects the mocked beans into the ActionEventUtils class.
* Because ActionEventUtils has static methods, we must also remember these fields
@ -149,8 +147,8 @@ public class ActionEventUtilsTest {
public void setupCommonMocks() throws Exception {
//Some basic mocks.
Mockito.when(configDao.getValue(Config.PublishActionEvent.key())).thenReturn("true");
PowerMockito.mockStatic(ComponentContext.class);
Mockito.when(ComponentContext.getComponent(EventBus.class)).thenReturn(eventBus);
componentContextMocked = Mockito.mockStatic(ComponentContext.class);
componentContextMocked.when(() -> ComponentContext.getComponent(EventBus.class)).thenReturn(eventBus);
//Needed for persist to actually set an ID that can be returned from the ActionEventUtils
//methods.
@ -205,6 +203,8 @@ public class ActionEventUtilsTest {
}
utils.init();
componentContextMocked.close();
}
@Test
@ -293,9 +293,6 @@ public class ActionEventUtilsTest {
final Long resourceId = 1L;
final String resourceType = ApiCommandResourceType.VirtualMachine.toString();
final String resourceUuid = UUID.randomUUID().toString();
VirtualMachine vm = Mockito.mock(VirtualMachine.class);
Mockito.when(vm.getId()).thenReturn(resourceId);
Mockito.when(entityMgr.findByUuidIncludingRemoved(VirtualMachine.class, resourceUuid)).thenReturn(vm);
CallContext.current().putContextParameter(VirtualMachine.class, resourceUuid);
ActionEventUtils.onScheduledActionEvent(USER_ID, ACCOUNT_ID, EventTypes.EVENT_VM_START, "Test event", resourceId, resourceType, true, 0L);
@ -319,9 +316,6 @@ public class ActionEventUtilsTest {
final Long resourceId = 1L;
final String resourceType = ApiCommandResourceType.VirtualMachine.toString();
final String resourceUuid = UUID.randomUUID().toString();
VirtualMachine vm = Mockito.mock(VirtualMachine.class);
Mockito.when(vm.getId()).thenReturn(resourceId);
Mockito.when(entityMgr.findByUuidIncludingRemoved(VirtualMachine.class, resourceUuid)).thenReturn(vm);
CallContext.current().putContextParameter(VirtualMachine.class, resourceUuid);
ActionEventUtils.onCreatedActionEvent(USER_ID, ACCOUNT_ID, EventVO.LEVEL_INFO, EventTypes.EVENT_VM_START, true, "Test event", resourceId, resourceType);
@ -345,9 +339,6 @@ public class ActionEventUtilsTest {
final Long resourceId = 1L;
final String resourceType = ApiCommandResourceType.VirtualMachine.toString();
final String resourceUuid = UUID.randomUUID().toString();
VirtualMachine vm = Mockito.mock(VirtualMachine.class);
Mockito.when(vm.getId()).thenReturn(resourceId);
Mockito.when(entityMgr.findByUuidIncludingRemoved(VirtualMachine.class, resourceUuid)).thenReturn(vm);
CallContext.current().putContextParameter(VirtualMachine.class, resourceUuid);
ActionEventUtils.startNestedActionEvent(EventTypes.EVENT_VM_START, "Test event", resourceId, resourceType);
@ -374,7 +365,6 @@ public class ActionEventUtilsTest {
Volume volume = Mockito.mock(Volume.class);
Mockito.when(volume.getUuid()).thenReturn(resourceUuid);
Mockito.when(entityMgr.validEntityType(Snapshot.class)).thenReturn(true);
Mockito.when(entityMgr.validEntityType(Volume.class)).thenReturn(true);
Mockito.when(entityMgr.findByIdIncludingRemoved(Snapshot.class, snapshotResourceId)).thenReturn(snapshot);
Mockito.when(entityMgr.findByIdIncludingRemoved(Volume.class, resourceId)).thenReturn(volume);
ActionEventUtils.onActionEvent(USER_ID, ACCOUNT_ID, account.getDomainId(), EventTypes.EVENT_SNAPSHOT_CREATE, "Test event", snapshotResourceId, snapshotResourceType);
@ -398,7 +388,6 @@ public class ActionEventUtilsTest {
VirtualMachine vm = Mockito.mock(VirtualMachine.class);
Mockito.when(vm.getUuid()).thenReturn(resourceUuid);
Mockito.when(entityMgr.validEntityType(VMSnapshot.class)).thenReturn(true);
Mockito.when(entityMgr.validEntityType(VirtualMachine.class)).thenReturn(true);
Mockito.when(entityMgr.findByIdIncludingRemoved(VMSnapshot.class, vmSnapshotResourceId)).thenReturn(vmSnapshot);
Mockito.when(entityMgr.findByIdIncludingRemoved(VirtualMachine.class, resourceId)).thenReturn(vm);
ActionEventUtils.onActionEvent(USER_ID, ACCOUNT_ID, account.getDomainId(), EventTypes.EVENT_VM_SNAPSHOT_CREATE, "Test event", vmSnapshotResourceId, vmSnapshotResourceType);

29
server/src/test/java/com/cloud/event/EventControlsUnitTest.java
View File

@ -16,17 +16,13 @@
// under the License.
package com.cloud.event;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.when;
import java.util.Date;
import java.util.List;
import com.cloud.event.dao.EventDao;
import com.cloud.server.ManagementServerImpl;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import junit.framework.TestCase;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
@ -35,13 +31,14 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import java.util.Date;
import java.util.List;
import com.cloud.event.dao.EventDao;
import com.cloud.server.ManagementServerImpl;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.when;
public class EventControlsUnitTest extends TestCase {
private static final Logger s_logger = Logger.getLogger(EventControlsUnitTest.class);

16
server/src/test/java/com/cloud/event/dao/EventJoinDaoImplTest.java
View File

@ -17,8 +17,9 @@
package com.cloud.event.dao;
import java.util.UUID;
import com.cloud.api.query.vo.EventJoinVO;
import com.cloud.utils.db.EntityManager;
import com.cloud.vm.VirtualMachine;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.api.response.EventResponse;
import org.junit.Assert;
@ -27,16 +28,11 @@ import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.api.query.vo.EventJoinVO;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import com.cloud.vm.VirtualMachine;
import java.util.UUID;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ComponentContext.class)
@RunWith(MockitoJUnitRunner.class)
public class EventJoinDaoImplTest {
@Mock

50
server/src/test/java/com/cloud/ha/HighAvailabilityManagerImplTest.java
View File

@ -16,32 +16,6 @@
// under the License.
package com.cloud.ha;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.inject.Inject;
import org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.managed.context.ManagedContext;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.agent.AgentManager;
import com.cloud.alert.AlertManager;
import com.cloud.consoleproxy.ConsoleProxyManager;
@ -71,6 +45,30 @@ import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachineManager;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.managed.context.ManagedContext;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import javax.inject.Inject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
@RunWith(MockitoJUnitRunner.class)
public class HighAvailabilityManagerImplTest {

29
server/src/test/java/com/cloud/ha/KVMFencerTest.java
View File

@ -18,9 +18,18 @@
*/
package com.cloud.ha;
import java.util.Arrays;
import java.util.Collections;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.FenceAnswer;
import com.cloud.agent.api.FenceCommand;
import com.cloud.alert.AlertManager;
import com.cloud.exception.AgentUnavailableException;
import com.cloud.exception.OperationTimedoutException;
import com.cloud.host.HostVO;
import com.cloud.host.Status;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.resource.ResourceManager;
import com.cloud.vm.VirtualMachine;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -30,18 +39,8 @@ import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.agent.AgentManager;
import com.cloud.alert.AlertManager;
import com.cloud.agent.api.FenceAnswer;
import com.cloud.agent.api.FenceCommand;
import com.cloud.exception.AgentUnavailableException;
import com.cloud.exception.OperationTimedoutException;
import com.cloud.host.HostVO;
import com.cloud.host.Status;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.resource.ResourceManager;
import com.cloud.vm.VirtualMachine;
import java.util.Arrays;
import java.util.Collections;
@RunWith(MockitoJUnitRunner.class)
public class KVMFencerTest {

6
server/src/test/java/com/cloud/hypervisor/KVMGuruTest.java
View File

@ -36,6 +36,9 @@ import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachineProfile;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.utils.bytescale.ByteScaleUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -49,9 +52,6 @@ import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.utils.bytescale.ByteScaleUtils;
import org.junit.Assert;
@RunWith(MockitoJUnitRunner.class)
public class KVMGuruTest {

6
server/src/test/java/com/cloud/keystore/KeystoreTest.java
View File

@ -16,16 +16,14 @@
// under the License.
package com.cloud.keystore;
import com.cloud.api.ApiSerializerHelper;
import junit.framework.TestCase;
import org.apache.cloudstack.api.response.AlertResponse;
import org.apache.cloudstack.api.response.UserVmResponse;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import com.cloud.api.ApiSerializerHelper;
import junit.framework.TestCase;
public class KeystoreTest extends TestCase {
private final static Logger s_logger = Logger.getLogger(KeystoreTest.class);

28
server/src/test/java/com/cloud/metadata/ResourceMetaDataManagerTest.java
View File

@ -17,28 +17,26 @@
package com.cloud.metadata;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import java.util.Map;
import javax.naming.ConfigurationException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.server.ResourceManagerUtil;
import com.cloud.server.ResourceTag;
import com.cloud.server.TaggedResourceService;
import com.cloud.storage.dao.VolumeDetailsDao;
import com.cloud.vm.dao.NicDetailsDao;
import org.apache.commons.collections.map.HashedMap;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.server.ResourceTag;
import com.cloud.server.TaggedResourceService;
import com.cloud.storage.dao.VolumeDetailsDao;
import com.cloud.vm.dao.NicDetailsDao;
import javax.naming.ConfigurationException;
import java.util.Map;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
public class ResourceMetaDataManagerTest {

44
server/src/test/java/com/cloud/network/CreatePrivateNetworkTest.java
View File

@ -17,28 +17,6 @@
package com.cloud.network;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import com.cloud.utils.Pair;
import org.apache.cloudstack.acl.ControlledEntity.ACLType;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import com.cloud.dc.DataCenter.NetworkType;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
@ -62,11 +40,31 @@ import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.Pair;
import com.cloud.utils.db.DB;
import com.cloud.utils.db.TransactionLegacy;
import com.cloud.utils.exception.CloudRuntimeException;
import junit.framework.Assert;
import org.apache.cloudstack.acl.ControlledEntity.ACLType;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
//@Ignore("Requires database to be set up")
public class CreatePrivateNetworkTest {

46
server/src/test/java/com/cloud/network/DedicateGuestVlanRangesTest.java
View File

@ -17,29 +17,6 @@
package com.cloud.network;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.apache.cloudstack.api.command.admin.network.DedicateGuestVlanRangeCmd;
import org.apache.cloudstack.api.command.admin.network.ListDedicatedGuestVlanRangesCmd;
import org.apache.cloudstack.api.command.admin.network.ReleaseDedicatedGuestVlanRangeCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import com.cloud.dc.DataCenterVnetVO;
import com.cloud.dc.dao.DataCenterVnetDao;
import com.cloud.network.dao.AccountGuestVlanMapDao;
@ -54,8 +31,29 @@ import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.db.TransactionLegacy;
import junit.framework.Assert;
import org.apache.cloudstack.api.command.admin.network.DedicateGuestVlanRangeCmd;
import org.apache.cloudstack.api.command.admin.network.ListDedicatedGuestVlanRangesCmd;
import org.apache.cloudstack.api.command.admin.network.ReleaseDedicatedGuestVlanRangeCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.when;
public class DedicateGuestVlanRangesTest {

36
server/src/test/java/com/cloud/network/ExternalLoadBalancerDeviceManagerImplTest.java
View File

@ -17,25 +17,6 @@
package com.cloud.network;
import java.lang.reflect.Field;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import javax.inject.Inject;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.Command;
import com.cloud.agent.api.routing.HealthCheckLBConfigAnswer;
@ -77,6 +58,23 @@ import com.cloud.vm.VirtualMachineManager;
import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.NicDao;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import javax.inject.Inject;
import java.lang.reflect.Field;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@RunWith(MockitoJUnitRunner.class)
public class ExternalLoadBalancerDeviceManagerImplTest {

49
server/src/test/java/com/cloud/network/IpAddressManagerTest.java
View File

@ -17,31 +17,6 @@
package com.cloud.network;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import com.cloud.user.Account;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.Network.Service;
import com.cloud.network.dao.IPAddressDao;
@ -52,8 +27,32 @@ import com.cloud.network.rules.StaticNat;
import com.cloud.network.rules.StaticNatImpl;
import com.cloud.offerings.NetworkOfferingVO;
import com.cloud.offerings.dao.NetworkOfferingDao;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.utils.net.Ip;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class IpAddressManagerTest {

17
server/src/test/java/com/cloud/network/Ipv6AddressManagerTest.java
View File

@ -17,15 +17,6 @@
package com.cloud.network;
import static org.mockito.Mockito.mock;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import com.cloud.dc.DataCenter;
import com.cloud.exception.InsufficientAddressCapacityException;
import com.cloud.exception.InvalidParameterValueException;
@ -40,6 +31,14 @@ import com.cloud.utils.net.NetUtils;
import com.cloud.vm.NicProfile;
import com.cloud.vm.dao.NicSecondaryIpDaoImpl;
import com.cloud.vm.dao.NicSecondaryIpVO;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.mock;
public class Ipv6AddressManagerTest {

94
server/src/test/java/com/cloud/network/Ipv6ServiceImplTest.java
View File

@ -16,39 +16,6 @@
// under the License.
package com.cloud.network;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanRegistrationException;
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import org.apache.cloudstack.api.command.user.ipv6.CreateIpv6FirewallRuleCmd;
import org.apache.cloudstack.api.command.user.ipv6.UpdateIpv6FirewallRuleCmd;
import org.apache.cloudstack.api.response.Ipv6RouteResponse;
import org.apache.cloudstack.api.response.VpcResponse;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.commons.collections.CollectionUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.api.ApiDBUtils;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterGuestIpv6PrefixVO;
@ -94,10 +61,38 @@ import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.NicDao;
import com.googlecode.ipv6.IPv6Network;
import com.googlecode.ipv6.IPv6NetworkMask;
import org.apache.cloudstack.api.command.user.ipv6.CreateIpv6FirewallRuleCmd;
import org.apache.cloudstack.api.command.user.ipv6.UpdateIpv6FirewallRuleCmd;
import org.apache.cloudstack.api.response.Ipv6RouteResponse;
import org.apache.cloudstack.api.response.VpcResponse;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.commons.collections.CollectionUtils;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
@PowerMockIgnore("javax.management.*")
@RunWith(PowerMockRunner.class)
@PrepareForTest({ApiDBUtils.class, ActionEventUtils.class, UsageEventUtils.class})
import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanRegistrationException;
import javax.management.MalformedObjectNameException;
import javax.management.NotCompliantMBeanException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
@RunWith(MockitoJUnitRunner.class)
public class Ipv6ServiceImplTest {
@Mock
@ -149,6 +144,11 @@ public class Ipv6ServiceImplTest {
private AccountVO account;
private UserVO user;
private MockedStatic<ApiDBUtils> apiDBUtilsMocked;
private MockedStatic<ActionEventUtils> actionEventUtilsMocked;
private MockedStatic<UsageEventUtils> usageEventUtilsMocked;
@Before
public void setup() {
updatedPrefixSubnetMap = new ArrayList<>();
@ -165,8 +165,17 @@ public class Ipv6ServiceImplTest {
persistedPrefixSubnetMap.add(map);
return map;
});
PowerMockito.mockStatic(ApiDBUtils.class);
Mockito.when(ApiDBUtils.findZoneById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
apiDBUtilsMocked = Mockito.mockStatic(ApiDBUtils.class);
apiDBUtilsMocked.when(() -> ApiDBUtils.findZoneById(Mockito.anyLong())).thenReturn(Mockito.mock(DataCenterVO.class));
actionEventUtilsMocked = Mockito.mockStatic(ActionEventUtils.class);
usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class);
}
@After
public void tearDown() throws Exception {
apiDBUtilsMocked.close();
actionEventUtilsMocked.close();
usageEventUtilsMocked.close();
}
private DataCenterGuestIpv6PrefixVO prepareMocksForIpv6Subnet() {
@ -396,7 +405,6 @@ public class Ipv6ServiceImplTest {
Nic nic = Mockito.mock(Nic.class);
Mockito.when(nic.getIPv6Address()).thenReturn(null);
Mockito.when(nic.getBroadcastUri()).thenReturn(URI.create(vlan));
Mockito.when(vlanDao.listIpv6RangeByZoneIdAndVlanId(1L, "vlan")).thenReturn(new ArrayList<>());
try (TransactionLegacy txn = TransactionLegacy.open("testNewErrorAssignPublicIpv6ToNetwork")) {
ipv6Service.assignPublicIpv6ToNetwork(Mockito.mock(Network.class), nic);
}
@ -417,7 +425,6 @@ public class Ipv6ServiceImplTest {
VlanVO vlanVO = Mockito.mock(VlanVO.class);
Mockito.when(vlanVO.getIp6Cidr()).thenReturn(cidr);
Mockito.when(vlanVO.getIp6Gateway()).thenReturn(gateway);
Mockito.when(vlanVO.getVlanType()).thenReturn(Vlan.VlanType.VirtualNetwork);
List<VlanVO> vlans = new ArrayList<>();
vlans.add(vlanVO);
Mockito.when(vlanDao.listIpv6RangeByZoneIdAndVlanId(Mockito.anyLong(), Mockito.anyString())).thenReturn(vlans);
@ -427,9 +434,7 @@ public class Ipv6ServiceImplTest {
}
Mockito.when(nicDao.listPlaceholderNicsByNetworkIdAndVmType(networkId, VirtualMachine.Type.DomainRouter)).thenReturn(placeholderNics);
Mockito.when(nicDao.createForUpdate(nicId)).thenReturn(new NicVO(publicReserver, 100L, 1L, VirtualMachine.Type.DomainRouter));
PowerMockito.mockStatic(ActionEventUtils.class);
Mockito.when(ActionEventUtils.onCompletedActionEvent(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyLong())).thenReturn(1L);
PowerMockito.mockStatic(UsageEventUtils.class);
}
@Test
@ -765,15 +770,12 @@ public class Ipv6ServiceImplTest {
removedNics.add((Long)invocation.getArguments()[0]);
return true;
});
PowerMockito.mockStatic(ActionEventUtils.class);
Mockito.when(ActionEventUtils.onCompletedActionEvent(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyLong())).thenReturn(1L);
PowerMockito.mockStatic(UsageEventUtils.class);
actionEventUtilsMocked.when(() -> ActionEventUtils.onCompletedActionEvent(Mockito.anyLong(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyLong())).thenReturn(1L);
ipv6Service.removePublicIpv6PlaceholderNics(network);
Assert.assertEquals(1, removedNics.size());
Assert.assertEquals(nicId, removedNics.get(0));
removedNics.clear();
NicVO nic1 = Mockito.mock(NicVO.class);
Mockito.when(nic1.getId()).thenReturn(nicId);
Mockito.when(nic1.getIPv6Address()).thenReturn(null);
Mockito.when(nicDao.listPlaceholderNicsByNetworkId(Mockito.anyLong())).thenReturn(List.of(nic1));
ipv6Service.removePublicIpv6PlaceholderNics(network);

12
server/src/test/java/com/cloud/network/MockFirewallManagerImpl.java
View File

@ -16,13 +16,6 @@
// under the License.
package com.cloud.network;
import java.util.List;
import java.util.Map;
import javax.naming.ConfigurationException;
import org.apache.cloudstack.api.command.user.firewall.IListFirewallRulesCmd;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.dao.IPAddressVO;
@ -36,6 +29,11 @@ import com.cloud.network.rules.FirewallRuleVO;
import com.cloud.user.Account;
import com.cloud.utils.Pair;
import com.cloud.utils.component.ManagerBase;
import org.apache.cloudstack.api.command.user.firewall.IListFirewallRulesCmd;
import javax.naming.ConfigurationException;
import java.util.List;
import java.util.Map;
public class MockFirewallManagerImpl extends ManagerBase implements FirewallManager, FirewallService {

13
server/src/test/java/com/cloud/network/MockNetworkModelImpl.java
View File

@ -17,13 +17,6 @@
package com.cloud.network;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.naming.ConfigurationException;
import com.cloud.dc.DataCenter;
import com.cloud.dc.Vlan;
import com.cloud.exception.InsufficientAddressCapacityException;
@ -51,6 +44,12 @@ import com.cloud.vm.Nic;
import com.cloud.vm.NicProfile;
import com.cloud.vm.VirtualMachine;
import javax.naming.ConfigurationException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class MockNetworkModelImpl extends ManagerBase implements NetworkModel {
/* (non-Javadoc)

7
server/src/test/java/com/cloud/network/NetworkModelImplTest.java
View File

@ -16,15 +16,14 @@
// under the License.
package com.cloud.network;
import com.cloud.dc.DataCenter;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.utils.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import com.cloud.dc.DataCenter;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.utils.Pair;
public class NetworkModelImplTest {
final String[] ip4Dns1 = {"5.5.5.5", "6.6.6.6"};
final String[] ip4Dns2 = {"7.7.7.7", "8.8.8.8"};

52
server/src/test/java/com/cloud/network/NetworkModelTest.java
View File

@ -17,32 +17,6 @@
package com.cloud.network;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import com.cloud.user.AccountManager;
import org.apache.cloudstack.network.NetworkPermissionVO;
import org.apache.cloudstack.network.dao.NetworkPermissionDao;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.VlanVO;
@ -65,6 +39,7 @@ import com.cloud.network.dao.PhysicalNetworkServiceProviderVO;
import com.cloud.network.dao.PhysicalNetworkVO;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.DomainManager;
import com.cloud.user.dao.AccountDao;
@ -73,8 +48,31 @@ import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.net.Ip;
import junit.framework.Assert;
import org.apache.cloudstack.network.NetworkPermissionVO;
import org.apache.cloudstack.network.dao.NetworkPermissionDao;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class NetworkModelTest {

166
server/src/test/java/com/cloud/network/NetworkServiceImplTest.java
View File

@ -16,55 +16,15 @@
// under the License.
package com.cloud.network;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.doReturn;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import com.cloud.exception.InsufficientAddressCapacityException;
import org.apache.cloudstack.alert.AlertService;
import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd;
import org.apache.cloudstack.api.command.user.network.UpdateNetworkCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.agent.api.to.IpAddressTO;
import com.cloud.alert.AlertManager;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.exception.InsufficientAddressCapacityException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.network.dao.IPAddressDao;
import com.cloud.network.dao.IPAddressVO;
@ -78,10 +38,13 @@ import com.cloud.network.vpc.VpcManager;
import com.cloud.network.vpc.VpcVO;
import com.cloud.network.vpc.dao.VpcDao;
import com.cloud.offering.NetworkOffering;
import com.cloud.offering.ServiceOffering;
import com.cloud.offerings.NetworkOfferingVO;
import com.cloud.offerings.dao.NetworkOfferingDao;
import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;
import com.cloud.org.Grouping;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountService;
@ -90,7 +53,6 @@ import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.user.dao.UserDao;
import com.cloud.utils.Pair;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.DomainRouterVO;
@ -98,14 +60,46 @@ import com.cloud.vm.NicVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.NicDao;
import com.cloud.offering.ServiceOffering;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.exception.InvalidParameterValueException;
import org.apache.cloudstack.alert.AlertService;
import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd;
import org.apache.cloudstack.api.command.user.network.UpdateNetworkCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@PowerMockIgnore("javax.management.*")
@RunWith(PowerMockRunner.class)
@PrepareForTest({ComponentContext.class, CallContext.class})
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class NetworkServiceImplTest {
@Mock
AccountManager accountManager;
@ -165,8 +159,6 @@ public class NetworkServiceImplTest {
@Mock
IpAddressManager ipAddressManager;
@Mock
ConfigKey<Integer> privateMtuKey;
@Mock
private CallContext callContextMock;
@InjectMocks
CreateNetworkCmd createNetworkCmd = new CreateNetworkCmd();
@ -200,6 +192,10 @@ public class NetworkServiceImplTest {
private PhysicalNetworkVO phyNet;
private VpcVO vpc;
private MockedStatic<CallContext> callContextMocked;
private AutoCloseable closeable;
private void registerCallContext() {
account = new AccountVO("testaccount", 1L, "networkdomain", Account.Type.NORMAL, "uuid");
account.setId(ACCOUNT_ID);
@ -212,9 +208,8 @@ public class NetworkServiceImplTest {
@Before
public void setup() throws Exception {
MockitoAnnotations.initMocks(this);
replaceUserChangeMtuField();
Mockito.when(userChangeMtuKey.valueIn(anyLong())).thenReturn(Boolean.TRUE);
closeable = MockitoAnnotations.openMocks(this);
overrideDefaultConfigValue(NetworkService.AllowUsersToSpecifyVRMtu, "_defaultValue", "true");
offering = Mockito.mock(NetworkOfferingVO.class);
network = Mockito.mock(Network.class);
dc = Mockito.mock(DataCenterVO.class);
@ -237,15 +232,14 @@ public class NetworkServiceImplTest {
service.commandSetupHelper = commandSetupHelper;
service.networkHelper = networkHelper;
service._ipAddrMgr = ipAddressManager;
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
accountMock = PowerMockito.mock(Account.class);
callContextMocked = Mockito.mockStatic(CallContext.class);
CallContext callContextMock = Mockito.mock(CallContext.class);
callContextMocked.when(CallContext::current).thenReturn(callContextMock);
accountMock = Mockito.mock(Account.class);
Mockito.when(service._accountMgr.finalizeOwner(any(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(accountMock);
PowerMockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock);
Mockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock);
NetworkOffering networkOffering = Mockito.mock(NetworkOffering.class);
Mockito.when(entityMgr.findById(NetworkOffering.class, 1L)).thenReturn(networkOffering);
Mockito.when(networkService.findPhysicalNetworkId(Mockito.anyLong(), ArgumentMatchers.nullable(String.class), Mockito.any(Networks.TrafficType.class))).thenReturn(1L);
Mockito.when(networkOfferingDao.findById(1L)).thenReturn(offering);
Mockito.when(physicalNetworkDao.findById(Mockito.anyLong())).thenReturn(phyNet);
Mockito.when(dcDao.findById(Mockito.anyLong())).thenReturn(dc);
@ -253,6 +247,18 @@ public class NetworkServiceImplTest {
Mockito.when(accountManager.isRootAdmin(accountMock.getId())).thenReturn(true);
}
@After
public void tearDown() throws Exception {
callContextMocked.close();
closeable.close();
}
private void overrideDefaultConfigValue(final ConfigKey configKey, final String name, final Object o) throws IllegalAccessException, NoSuchFieldException {
Field f = ConfigKey.class.getDeclaredField(name);
f.setAccessible(true);
f.set(configKey, o);
}
@Test
public void testGetPrivateVlanPairNoVlans() {
Pair<String, Network.PVlanType> pair = service.getPrivateVlanPair(null, null, null);
@ -373,8 +379,6 @@ public class NetworkServiceImplTest {
Integer publicMtu = 2450;
Integer privateMtu = 1500;
Long zoneId = 1L;
when(publicMtuKey.valueIn(zoneId)).thenReturn(NetworkService.DEFAULT_MTU);
when(privateMtuKey.valueIn(zoneId)).thenReturn(NetworkService.DEFAULT_MTU);
Pair<Integer, Integer> interfaceMtus = service.validateMtuConfig(publicMtu, privateMtu, zoneId);
Assert.assertNotNull(interfaceMtus);
Assert.assertEquals(NetworkService.DEFAULT_MTU, interfaceMtus.first());
@ -388,8 +392,6 @@ public class NetworkServiceImplTest {
Integer publicMtu = 1500;
Integer privateMtu = 2500;
Long zoneId = 1L;
when(publicMtuKey.valueIn(zoneId)).thenReturn(NetworkService.DEFAULT_MTU);
when(privateMtuKey.valueIn(zoneId)).thenReturn(NetworkService.DEFAULT_MTU);
Pair<Integer, Integer> interfaceMtus = service.validateMtuConfig(publicMtu, privateMtu, zoneId);
Assert.assertNotNull(interfaceMtus);
Assert.assertEquals(NetworkService.DEFAULT_MTU, interfaceMtus.first());
@ -445,20 +447,8 @@ public class NetworkServiceImplTest {
routers.add(routerPrimary);
CallContext.register(callingUser, callingAccount);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.doReturn(1L).when(callContextMock).getCallingUserId();
Mockito.when(userDao.findById(anyLong())).thenReturn(userVO);
Mockito.when(accountService.getActiveUser(1L)).thenReturn(callingUser);
Mockito.when(callingUser.getAccountId()).thenReturn(1L);
Mockito.when(accountService.getActiveAccountById(anyLong())).thenReturn(callingAccount);
Mockito.when(networkDao.findById(anyLong())).thenReturn(networkVO);
Mockito.when(networkOfferingDao.findByIdIncludingRemoved(anyLong())).thenReturn(offering);
Mockito.when(offering.isSystemOnly()).thenReturn(false);
Mockito.when(networkVO.getTrafficType()).thenReturn(Networks.TrafficType.Guest);
Mockito.when(networkVO.getGuestType()).thenReturn(Network.GuestType.Shared);
Mockito.when(nicDao.listByNetworkIdAndType(anyLong(), any(VirtualMachine.Type.class))).thenReturn(List.of(Mockito.mock(NicVO.class)));
Mockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.when(networkVO.getVpcId()).thenReturn(null);
Mockito.when(ipAddressDao.listByNetworkId(anyLong())).thenReturn(addresses);
Pair<Integer, Integer> updatedMtus = service.validateMtuOnUpdate(networkVO, zoneId, publicMtu, privateMtu);
Assert.assertEquals(publicMtu, updatedMtus.first());
@ -491,36 +481,19 @@ public class NetworkServiceImplTest {
Assert.assertEquals(privateMtu, updatedMtus.second());
}
private void replaceUserChangeMtuField() throws Exception {
Field field = NetworkService.class.getDeclaredField("AllowUsersToSpecifyVRMtu");
field.setAccessible(true);
// remove final modifier from field
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.set(null, userChangeMtuKey);
}
private void prepareCreateNetworkDnsMocks(CreateNetworkCmd cmd, Network.GuestType guestType, boolean ipv6, boolean isVpc, boolean dnsServiceSupported) {
long networkOfferingId = 1L;
Mockito.when(cmd.getNetworkOfferingId()).thenReturn(networkOfferingId);
NetworkOfferingVO networkOfferingVO = Mockito.mock(NetworkOfferingVO.class);
Mockito.when(networkOfferingVO.getId()).thenReturn(networkOfferingId);
Mockito.when(networkOfferingVO.getGuestType()).thenReturn(guestType);
Mockito.when(networkOfferingVO.getTrafficType()).thenReturn(Networks.TrafficType.Guest);
Mockito.when(networkOfferingVO.isSpecifyIpRanges()).thenReturn(true);
Mockito.when(networkOfferingDao.findById(networkOfferingId)).thenReturn(networkOfferingVO);
if (Network.GuestType.Shared.equals(guestType)) {
Mockito.when(networkModel.isProviderForNetworkOffering(Mockito.any(), Mockito.anyLong())).thenReturn(true);
Mockito.when(cmd.getGateway()).thenReturn(IP4_GATEWAY);
Mockito.when(cmd.getNetmask()).thenReturn(IP4_NETMASK);
}
Mockito.when(accountManager.isNormalUser(Mockito.anyLong())).thenReturn(true);
Mockito.when(physicalNetworkDao.findById(Mockito.anyLong())).thenReturn(Mockito.mock(PhysicalNetworkVO.class));
DataCenterVO zone = Mockito.mock(DataCenterVO.class);
Mockito.when(zone.getNetworkType()).thenReturn(DataCenter.NetworkType.Advanced);
Mockito.when(dataCenterDao.findById(Mockito.anyLong())).thenReturn(zone);
Mockito.when(networkOrchestrationService.finalizeServicesAndProvidersForNetwork(Mockito.any(), Mockito.anyLong())).thenReturn(new HashMap<>());
Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(networkOfferingId, Network.Service.Dns)).thenReturn(dnsServiceSupported);
if(ipv6 && Network.GuestType.Isolated.equals(guestType)) {
Mockito.when(networkOfferingDao.isIpv6Supported(networkOfferingId)).thenReturn(true);
@ -716,10 +689,7 @@ public class NetworkServiceImplTest {
Assert.fail(String.format("Unable to set network guestType, %s", e.getMessage()));
}
networkVO.setIp6Cidr("cidr");
Long offeringId = 1L;
NetworkOffering offering = Mockito.mock(NetworkOffering.class);
Mockito.when(offering.getId()).thenReturn(offeringId);
Mockito.when(networkOfferingServiceMapDao.areServicesSupportedByNetworkOffering(offeringId, Network.Service.Dns)).thenReturn(true);
boolean updated = service.checkAndUpdateNetworkDns(networkVO, offering, "", null, "", null);
Assert.assertTrue(updated);
Assert.assertNull(networkVO.getDns1());

25
server/src/test/java/com/cloud/network/UpdatePhysicalNetworkTest.java
View File

@ -16,25 +16,24 @@
// under the License.
package com.cloud.network;
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.dc.dao.DataCenterVnetDao;
import com.cloud.network.dao.PhysicalNetworkDao;
import com.cloud.network.dao.PhysicalNetworkVO;
import com.cloud.utils.db.TransactionLegacy;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class UpdatePhysicalNetworkTest {
private PhysicalNetworkDao _physicalNetworkDao = mock(PhysicalNetworkDao.class);

417
server/src/test/java/com/cloud/network/as/AutoScaleManagerImplTest.java
View File

@ -16,66 +16,6 @@
// under the License.
package com.cloud.network.as;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.matches;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import org.apache.cloudstack.affinity.AffinityGroupVO;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.annotation.AnnotationService;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.command.admin.autoscale.CreateCounterCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateAutoScalePolicyCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateAutoScaleVmGroupCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateAutoScaleVmProfileCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateConditionCmd;
import org.apache.cloudstack.api.command.user.autoscale.ListCountersCmd;
import org.apache.cloudstack.api.command.user.autoscale.UpdateAutoScaleVmGroupCmd;
import org.apache.cloudstack.api.command.user.autoscale.UpdateAutoScaleVmProfileCmd;
import org.apache.cloudstack.api.command.user.autoscale.UpdateConditionCmd;
import org.apache.cloudstack.api.command.user.vm.DeployVMCmd;
import org.apache.cloudstack.config.ApiServiceConfiguration;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.PerformanceMonitorAnswer;
import com.cloud.agent.api.PerformanceMonitorCommand;
@ -125,7 +65,6 @@ import com.cloud.network.router.VirtualRouter;
import com.cloud.network.router.VirtualRouterAutoScale;
import com.cloud.network.router.VirtualRouterAutoScale.AutoScaleValueType;
import com.cloud.network.router.VirtualRouterAutoScale.VirtualRouterAutoScaleCounter;
import com.cloud.network.rules.LoadBalancer;
import com.cloud.offering.DiskOffering;
import com.cloud.offering.ServiceOffering;
import com.cloud.offerings.NetworkOfferingVO;
@ -165,9 +104,65 @@ import com.cloud.vm.VmStats;
import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.affinity.AffinityGroupVO;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.annotation.AnnotationService;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.command.admin.autoscale.CreateCounterCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateAutoScalePolicyCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateAutoScaleVmGroupCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateAutoScaleVmProfileCmd;
import org.apache.cloudstack.api.command.user.autoscale.CreateConditionCmd;
import org.apache.cloudstack.api.command.user.autoscale.ListCountersCmd;
import org.apache.cloudstack.api.command.user.autoscale.UpdateAutoScaleVmGroupCmd;
import org.apache.cloudstack.api.command.user.autoscale.UpdateAutoScaleVmProfileCmd;
import org.apache.cloudstack.api.command.user.autoscale.UpdateConditionCmd;
import org.apache.cloudstack.api.command.user.vm.DeployVMCmd;
import org.apache.cloudstack.config.ApiServiceConfiguration;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PowerMockIgnore("javax.management.*")
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.matches;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class AutoScaleManagerImplTest {
@Spy
@ -733,7 +728,6 @@ public class AutoScaleManagerImplTest {
}
@Test
@PrepareForTest(ComponentContext.class)
public void testCreateAutoScaleVmProfile() {
when(entityManager.findById(DataCenter.class, zoneId)).thenReturn(zoneMock);
when(entityManager.findById(ServiceOffering.class, serviceOfferingId)).thenReturn(serviceOfferingMock);
@ -744,73 +738,70 @@ public class AutoScaleManagerImplTest {
DispatchChain dispatchChainMock = Mockito.mock(DispatchChain.class);
when(dispatchChainFactory.getStandardDispatchChain()).thenReturn(dispatchChainMock);
Mockito.doNothing().when(dispatchChainMock).dispatch(any());
PowerMockito.mockStatic(ComponentContext.class);
when(ComponentContext.inject(DeployVMCmd.class)).thenReturn(Mockito.mock(DeployVMCmd.class));
try (MockedStatic<ComponentContext> ignored = Mockito.mockStatic(ComponentContext.class)) {
when(ComponentContext.inject(DeployVMCmd.class)).thenReturn(Mockito.mock(DeployVMCmd.class));
when(autoScaleVmProfileDao.persist(any())).thenReturn(asVmProfileMock);
CreateAutoScaleVmProfileCmd cmd = new CreateAutoScaleVmProfileCmd();
when(autoScaleVmProfileDao.persist(any())).thenReturn(asVmProfileMock);
CreateAutoScaleVmProfileCmd cmd = new CreateAutoScaleVmProfileCmd();
ReflectionTestUtils.setField(cmd, "zoneId", zoneId);
ReflectionTestUtils.setField(cmd, "serviceOfferingId", serviceOfferingId);
ReflectionTestUtils.setField(cmd, "templateId", templateId);
ReflectionTestUtils.setField(cmd, "expungeVmGracePeriod", expungeVmGracePeriod);
ReflectionTestUtils.setField(cmd, "otherDeployParams", otherDeployParams);
ReflectionTestUtils.setField(cmd, "counterParamList", counterParamList);
ReflectionTestUtils.setField(cmd, "zoneId", zoneId);
ReflectionTestUtils.setField(cmd, "serviceOfferingId", serviceOfferingId);
ReflectionTestUtils.setField(cmd, "templateId", templateId);
ReflectionTestUtils.setField(cmd, "expungeVmGracePeriod", expungeVmGracePeriod);
ReflectionTestUtils.setField(cmd, "otherDeployParams", otherDeployParams);
ReflectionTestUtils.setField(cmd, "counterParamList", counterParamList);
ReflectionTestUtils.setField(cmd, "userData", userData);
ReflectionTestUtils.setField(cmd, "userDataId", userDataId);
ReflectionTestUtils.setField(cmd, "userDataDetails", userDataDetails);
ReflectionTestUtils.setField(cmd, "userData", userData);
ReflectionTestUtils.setField(cmd, "userDataId", userDataId);
ReflectionTestUtils.setField(cmd, "userDataDetails", userDataDetails);
AutoScaleVmProfile vmProfile = autoScaleManagerImplSpy.createAutoScaleVmProfile(cmd);
AutoScaleVmProfile vmProfile = autoScaleManagerImplSpy.createAutoScaleVmProfile(cmd);
Assert.assertEquals(asVmProfileMock, vmProfile);
Mockito.verify(autoScaleVmProfileDao).persist(Mockito.any());
Assert.assertEquals(asVmProfileMock, vmProfile);
Mockito.verify(autoScaleVmProfileDao).persist(Mockito.any());
Mockito.verify(userVmMgr).finalizeUserData(any(), any(), any());
Mockito.verify(userVmMgr).validateUserData(eq(userDataFinal), nullable(BaseCmd.HTTPMethod.class));
Mockito.verify(userVmMgr).finalizeUserData(any(), any(), any());
Mockito.verify(userVmMgr).validateUserData(eq(userDataFinal), nullable(BaseCmd.HTTPMethod.class));
}
}
@Test(expected = InvalidParameterValueException.class)
@PrepareForTest(ComponentContext.class)
public void testCreateAutoScaleVmProfileFail() {
when(entityManager.findById(DataCenter.class, zoneId)).thenReturn(zoneMock);
when(entityManager.findById(ServiceOffering.class, serviceOfferingId)).thenReturn(serviceOfferingMock);
when(entityManager.findByIdIncludingRemoved(ServiceOffering.class, serviceOfferingId)).thenReturn(serviceOfferingMock);
when(entityManager.findById(VirtualMachineTemplate.class, templateId)).thenReturn(templateMock);
when(serviceOfferingMock.isDynamic()).thenReturn(false);
Mockito.doThrow(InvalidParameterValueException.class).when(userVmMgr).finalizeUserData(any(), any(), any());
DispatchChain dispatchChainMock = Mockito.mock(DispatchChain.class);
when(dispatchChainFactory.getStandardDispatchChain()).thenReturn(dispatchChainMock);
Mockito.doNothing().when(dispatchChainMock).dispatch(any());
PowerMockito.mockStatic(ComponentContext.class);
when(ComponentContext.inject(DeployVMCmd.class)).thenReturn(Mockito.mock(DeployVMCmd.class));
try (MockedStatic<ComponentContext> ignored = Mockito.mockStatic(ComponentContext.class)) {
when(ComponentContext.inject(DeployVMCmd.class)).thenReturn(Mockito.mock(DeployVMCmd.class));
CreateAutoScaleVmProfileCmd cmd = new CreateAutoScaleVmProfileCmd();
CreateAutoScaleVmProfileCmd cmd = new CreateAutoScaleVmProfileCmd();
ReflectionTestUtils.setField(cmd, "zoneId", zoneId);
ReflectionTestUtils.setField(cmd, "serviceOfferingId", serviceOfferingId);
ReflectionTestUtils.setField(cmd, "templateId", templateId);
ReflectionTestUtils.setField(cmd, "expungeVmGracePeriod", expungeVmGracePeriod);
ReflectionTestUtils.setField(cmd, "otherDeployParams", otherDeployParams);
ReflectionTestUtils.setField(cmd, "counterParamList", counterParamList);
ReflectionTestUtils.setField(cmd, "zoneId", zoneId);
ReflectionTestUtils.setField(cmd, "serviceOfferingId", serviceOfferingId);
ReflectionTestUtils.setField(cmd, "templateId", templateId);
ReflectionTestUtils.setField(cmd, "expungeVmGracePeriod", expungeVmGracePeriod);
ReflectionTestUtils.setField(cmd, "otherDeployParams", otherDeployParams);
ReflectionTestUtils.setField(cmd, "counterParamList", counterParamList);
ReflectionTestUtils.setField(cmd, "userData", userData);
ReflectionTestUtils.setField(cmd, "userDataId", userDataId);
ReflectionTestUtils.setField(cmd, "userData", userData);
ReflectionTestUtils.setField(cmd, "userDataId", userDataId);
AutoScaleVmProfile vmProfile = autoScaleManagerImplSpy.createAutoScaleVmProfile(cmd);
AutoScaleVmProfile vmProfile = autoScaleManagerImplSpy.createAutoScaleVmProfile(cmd);
}
}
@Test
public void testUpdateAutoScaleVmProfile() {
when(autoScaleVmProfileDao.findById(vmProfileId)).thenReturn(asVmProfileMock);
when(autoScaleVmGroupDao.listByAll(null, vmProfileId)).thenReturn(new ArrayList<>());
when(autoScaleVmGroupDao.listByProfile(vmProfileId)).thenReturn(new ArrayList<>());
when(autoScaleVmProfileDao.persist(any())).thenReturn(asVmProfileMock);
when(asVmProfileMock.getServiceOfferingId()).thenReturn(serviceOfferingId);
when(asVmProfileMock.getTemplateId()).thenReturn(templateId);
when(entityManager.findById(ServiceOffering.class, serviceOfferingId)).thenReturn(serviceOfferingMock);
when(entityManager.findByIdIncludingRemoved(ServiceOffering.class, serviceOfferingId)).thenReturn(serviceOfferingMock);
when(entityManager.findById(VirtualMachineTemplate.class, templateId)).thenReturn(templateMock);
when(serviceOfferingMock.isDynamic()).thenReturn(false);
@ -939,7 +930,6 @@ public class AutoScaleManagerImplTest {
ReflectionTestUtils.setField(cmd, "scaleDownPolicyIds", Arrays.asList(scaleDownPolicyId));
ReflectionTestUtils.setField(cmd, "profileId", vmProfileId);
when(entityManager.findById(LoadBalancer.class, loadBalancerId)).thenReturn(loadBalancerMock);
when(loadBalancerMock.getAccountId()).thenReturn(accountId);
when(loadBalancerMock.getDomainId()).thenReturn(domainId);
when(loadBalancerMock.getDefaultPortStart()).thenReturn(memberPort);
@ -955,10 +945,8 @@ public class AutoScaleManagerImplTest {
SearchBuilder<AutoScalePolicyVO> searchBuilderMock = Mockito.mock(SearchBuilder.class);
SearchCriteria<AutoScalePolicyVO> searchCriteriaMock = Mockito.mock(SearchCriteria.class);
when(asScaleUpPolicyMock.getDuration()).thenReturn(scaleUpPolicyDuration);
when(asScaleUpPolicyMock.getQuietTime()).thenReturn(scaleUpPolicyQuietTime);
when(asScaleUpPolicyMock.getAction()).thenReturn(AutoScalePolicy.Action.SCALEUP);
when(asScaleDownPolicyMock.getDuration()).thenReturn(scaleDownPolicyDuration);
when(asScaleDownPolicyMock.getQuietTime()).thenReturn(scaleDownPolicyQuietTime);
when(asScaleDownPolicyMock.getAction()).thenReturn(AutoScalePolicy.Action.SCALEDOWN);
Mockito.doReturn(searchBuilderMock).when(asPolicyDao).createSearchBuilder();
@ -967,8 +955,8 @@ public class AutoScaleManagerImplTest {
when(asPolicyDao.search(searchCriteriaMock, null)).thenReturn(Arrays.asList(asScaleUpPolicyMock)).thenReturn(Arrays.asList(asScaleDownPolicyMock));
when(autoScaleVmProfileDao.findById(vmProfileId)).thenReturn(asVmProfileMock);
PowerMockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).validateAutoScaleCounters(anyLong(), any(), any());
Mockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
Mockito.doNothing().when(autoScaleManagerImplSpy).validateAutoScaleCounters(anyLong(), any(), any());
when(loadBalancerMock.getNetworkId()).thenReturn(networkId);
when(networkDao.findById(networkId)).thenReturn(networkMock);
when(networkMock.getNetworkOfferingId()).thenReturn(networkOfferingId);
@ -977,7 +965,7 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupDao.persist(any())).thenReturn(asVmGroupMock);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).scheduleMonitorTask(anyLong());
Mockito.doNothing().when(autoScaleManagerImplSpy).scheduleMonitorTask(anyLong());
AutoScaleVmGroup vmGroup = autoScaleManagerImplSpy.createAutoScaleVmGroup(cmd);
@ -998,7 +986,7 @@ public class AutoScaleManagerImplTest {
List<AutoScaleCounter> supportedAutoScaleCounters = Arrays.asList(new AutoScaleCounter(AutoScaleCounter.AutoScaleCounterType.Cpu),
new AutoScaleCounter(AutoScaleCounter.AutoScaleCounterType.Memory),
new AutoScaleCounter(AutoScaleCounter.AutoScaleCounterType.VirtualRouter));
PowerMockito.doReturn(supportedAutoScaleCounters).when(autoScaleManagerImplSpy).getSupportedAutoScaleCounters(networkId);
Mockito.doReturn(supportedAutoScaleCounters).when(autoScaleManagerImplSpy).getSupportedAutoScaleCounters(networkId);
autoScaleManagerImplSpy.validateAutoScaleCounters(networkId, counters, new ArrayList<>());
@ -1016,7 +1004,7 @@ public class AutoScaleManagerImplTest {
List<AutoScaleCounter> supportedAutoScaleCounters = Arrays.asList(new AutoScaleCounter(AutoScaleCounter.AutoScaleCounterType.Cpu),
new AutoScaleCounter(AutoScaleCounter.AutoScaleCounterType.VirtualRouter));
PowerMockito.doReturn(supportedAutoScaleCounters).when(autoScaleManagerImplSpy).getSupportedAutoScaleCounters(networkId);
Mockito.doReturn(supportedAutoScaleCounters).when(autoScaleManagerImplSpy).getSupportedAutoScaleCounters(networkId);
autoScaleManagerImplSpy.validateAutoScaleCounters(networkId, counters, new ArrayList<>());
@ -1045,10 +1033,8 @@ public class AutoScaleManagerImplTest {
SearchBuilder<AutoScalePolicyVO> searchBuilderMock = Mockito.mock(SearchBuilder.class);
SearchCriteria<AutoScalePolicyVO> searchCriteriaMock = Mockito.mock(SearchCriteria.class);
when(asScaleUpPolicyMock.getDuration()).thenReturn(scaleUpPolicyDuration);
when(asScaleUpPolicyMock.getQuietTime()).thenReturn(scaleUpPolicyQuietTime);
when(asScaleUpPolicyMock.getAction()).thenReturn(AutoScalePolicy.Action.SCALEUP);
when(asScaleDownPolicyMock.getDuration()).thenReturn(scaleDownPolicyDuration);
when(asScaleDownPolicyMock.getQuietTime()).thenReturn(scaleDownPolicyQuietTime);
when(asScaleDownPolicyMock.getAction()).thenReturn(AutoScalePolicy.Action.SCALEDOWN);
Mockito.doReturn(searchBuilderMock).when(asPolicyDao).createSearchBuilder();
@ -1058,8 +1044,8 @@ public class AutoScaleManagerImplTest {
when(lbDao.findById(loadBalancerId)).thenReturn(loadBalancerMock);
when(autoScaleVmProfileDao.findById(vmProfileId)).thenReturn(asVmProfileMock);
PowerMockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).validateAutoScaleCounters(anyLong(), any(), any());
Mockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
Mockito.doNothing().when(autoScaleManagerImplSpy).validateAutoScaleCounters(anyLong(), any(), any());
when(loadBalancerMock.getNetworkId()).thenReturn(networkId);
when(networkDao.findById(networkId)).thenReturn(networkMock);
when(networkMock.getNetworkOfferingId()).thenReturn(networkOfferingId);
@ -1068,8 +1054,6 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupDao.persist(any())).thenReturn(asVmGroupMock);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).scheduleMonitorTask(anyLong());
AutoScaleVmGroup vmGroup = autoScaleManagerImplSpy.updateAutoScaleVmGroup(cmd);
Assert.assertEquals(asVmGroupMock, vmGroup);
@ -1092,10 +1076,7 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
when(asVmGroupMock.getInterval()).thenReturn(interval);
when(asVmGroupMock.getMaxMembers()).thenReturn(maxMembers);
when(asVmGroupMock.getMinMembers()).thenReturn(minMembers);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(asVmGroupMock.getProfileId()).thenReturn(vmProfileId);
AutoScaleVmGroup vmGroup = autoScaleManagerImplSpy.updateAutoScaleVmGroup(cmd);
}
@ -1144,8 +1125,8 @@ public class AutoScaleManagerImplTest {
when(asVmGroupMock.getId()).thenReturn(vmGroupId);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.DISABLED);
when(autoScaleVmGroupDao.persist(any())).thenReturn(asVmGroupMock);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).configureAutoScaleVmGroup(vmGroupId, AutoScaleVmGroup.State.DISABLED);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).scheduleMonitorTask(anyLong());
Mockito.doReturn(true).when(autoScaleManagerImplSpy).configureAutoScaleVmGroup(vmGroupId, AutoScaleVmGroup.State.DISABLED);
Mockito.doNothing().when(autoScaleManagerImplSpy).scheduleMonitorTask(anyLong());
AutoScaleVmGroup vmGroup = autoScaleManagerImplSpy.enableAutoScaleVmGroup(vmGroupId);
@ -1179,8 +1160,7 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(autoScaleVmGroupDao.persist(any())).thenReturn(asVmGroupMock);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).configureAutoScaleVmGroup(vmGroupId, AutoScaleVmGroup.State.ENABLED);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).scheduleMonitorTask(anyLong());
Mockito.doReturn(true).when(autoScaleManagerImplSpy).configureAutoScaleVmGroup(vmGroupId, AutoScaleVmGroup.State.ENABLED);
AutoScaleVmGroup vmGroup = autoScaleManagerImplSpy.disableAutoScaleVmGroup(vmGroupId);
@ -1207,10 +1187,10 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupVmMapDao.countByGroup(vmGroupId)).thenReturn(1);
when(autoScaleVmGroupVmMapDao.listByGroup(vmGroupId)).thenReturn(Arrays.asList(autoScaleVmGroupVmMapVOMock));
when(autoScaleVmGroupVmMapVOMock.getInstanceId()).thenReturn(virtualMachineId);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).destroyVm(virtualMachineId);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).configureAutoScaleVmGroup(vmGroupId, AutoScaleVmGroup.State.ENABLED);
Mockito.doReturn(true).when(autoScaleManagerImplSpy).destroyVm(virtualMachineId);
Mockito.doReturn(true).when(autoScaleManagerImplSpy).configureAutoScaleVmGroup(vmGroupId, AutoScaleVmGroup.State.ENABLED);
when(autoScaleVmGroupDao.remove(vmGroupId)).thenReturn(true);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).cancelMonitorTask(vmGroupId);
Mockito.doNothing().when(autoScaleManagerImplSpy).cancelMonitorTask(vmGroupId);
when(autoScaleVmGroupPolicyMapDao.removeByGroupId(vmGroupId)).thenReturn(true);
when(autoScaleVmGroupVmMapDao.removeByGroup(vmGroupId)).thenReturn(true);
when(asGroupStatisticsDao.removeByGroupId(vmGroupId)).thenReturn(true);
@ -1275,7 +1255,7 @@ public class AutoScaleManagerImplTest {
when(zoneMock.isLocalStorageEnabled()).thenReturn(false);
when(diskOfferingMock.isUseLocalStorage()).thenReturn(false);
PowerMockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
Mockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
when(networkMock.getId()).thenReturn(networkId);
when(userVmMock.getId()).thenReturn(virtualMachineId);
@ -1323,7 +1303,7 @@ public class AutoScaleManagerImplTest {
when(zoneMock.isLocalStorageEnabled()).thenReturn(false);
when(diskOfferingMock.isUseLocalStorage()).thenReturn(false);
PowerMockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
Mockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
when(networkMock.getId()).thenReturn(networkId);
when(userVmMock.getId()).thenReturn(virtualMachineId);
@ -1372,7 +1352,7 @@ public class AutoScaleManagerImplTest {
when(zoneMock.isLocalStorageEnabled()).thenReturn(false);
when(diskOfferingMock.isUseLocalStorage()).thenReturn(false);
PowerMockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
Mockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
when(networkMock.getId()).thenReturn(networkId);
when(userVmMock.getId()).thenReturn(virtualMachineId);
@ -1504,62 +1484,61 @@ public class AutoScaleManagerImplTest {
}
@Test
@PrepareForTest(ActionEventUtils.class)
public void testDoScaleUp() throws ResourceUnavailableException, InsufficientCapacityException, ResourceAllocationException {
PowerMockito.mockStatic(ActionEventUtils.class);
try (MockedStatic<ActionEventUtils> ignored = Mockito.mockStatic(ActionEventUtils.class)) {
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
when(asVmGroupMock.getId()).thenReturn(vmGroupId);
when(asVmGroupMock.getMaxMembers()).thenReturn(maxMembers);
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(maxMembers - 1);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
when(asVmGroupMock.getId()).thenReturn(vmGroupId);
when(asVmGroupMock.getMaxMembers()).thenReturn(maxMembers);
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(maxMembers - 1);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.ENABLED, AutoScaleVmGroup.State.SCALING)).thenReturn(true);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.SCALING, AutoScaleVmGroup.State.ENABLED)).thenReturn(true);
Mockito.doReturn(virtualMachineId).when(autoScaleManagerImplSpy).createNewVM(asVmGroupMock);
Pair<UserVmVO, Map<VirtualMachineProfile.Param, Object>> startVm = Mockito.mock(Pair.class);
when(userVmMgr.startVirtualMachine(virtualMachineId, null, null, null)).thenReturn(startVm);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.ENABLED, AutoScaleVmGroup.State.SCALING)).thenReturn(true);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.SCALING, AutoScaleVmGroup.State.ENABLED)).thenReturn(true);
PowerMockito.doReturn(virtualMachineId).when(autoScaleManagerImplSpy).createNewVM(asVmGroupMock);
Pair<UserVmVO, Map<VirtualMachineProfile.Param, Object>> startVm = Mockito.mock(Pair.class);
when(userVmMgr.startVirtualMachine(virtualMachineId, null, null, null)).thenReturn(startVm);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
when(lbVmMapDao.listByLoadBalancerId(loadBalancerId)).thenReturn(Arrays.asList(loadBalancerVMMapMock));
when(loadBalancerVMMapMock.getInstanceId()).thenReturn(virtualMachineId + 1);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
when(lbVmMapDao.listByLoadBalancerId(loadBalancerId)).thenReturn(Arrays.asList(loadBalancerVMMapMock));
when(loadBalancerVMMapMock.getInstanceId()).thenReturn(virtualMachineId + 1);
when(loadBalancingRulesService.assignToLoadBalancer(anyLong(), any(), any(), eq(true))).thenReturn(true);
when(loadBalancingRulesService.assignToLoadBalancer(anyLong(), any(), any(), eq(true))).thenReturn(true);
autoScaleManagerImplSpy.doScaleUp(vmGroupId, 1);
autoScaleManagerImplSpy.doScaleUp(vmGroupId, 1);
Mockito.verify(autoScaleManagerImplSpy).createNewVM(asVmGroupMock);
Mockito.verify(loadBalancingRulesService).assignToLoadBalancer(anyLong(), any(), any(), eq(true));
Mockito.verify(autoScaleManagerImplSpy).createNewVM(asVmGroupMock);
Mockito.verify(loadBalancingRulesService).assignToLoadBalancer(anyLong(), any(), any(), eq(true));
}
}
@Test
@PrepareForTest(ActionEventUtils.class)
public void testDoScaleDown() {
PowerMockito.mockStatic(ActionEventUtils.class);
try (MockedStatic<ActionEventUtils> ignored = Mockito.mockStatic(ActionEventUtils.class)) {
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
when(asVmGroupMock.getId()).thenReturn(vmGroupId);
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
when(asVmGroupMock.getId()).thenReturn(vmGroupId);
when(asVmGroupMock.getMinMembers()).thenReturn(minMembers);
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(minMembers + 1);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(asVmGroupMock.getMinMembers()).thenReturn(minMembers);
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(minMembers + 1);
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.ENABLED, AutoScaleVmGroup.State.SCALING)).thenReturn(true);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.SCALING, AutoScaleVmGroup.State.ENABLED)).thenReturn(true);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.ENABLED, AutoScaleVmGroup.State.SCALING)).thenReturn(true);
when(autoScaleVmGroupDao.updateState(vmGroupId, AutoScaleVmGroup.State.SCALING, AutoScaleVmGroup.State.ENABLED)).thenReturn(true);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
when(lbVmMapDao.listByLoadBalancerId(loadBalancerId)).thenReturn(Arrays.asList(loadBalancerVMMapMock));
when(loadBalancerVMMapMock.getInstanceId()).thenReturn(virtualMachineId);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
when(lbVmMapDao.listByLoadBalancerId(loadBalancerId)).thenReturn(Arrays.asList(loadBalancerVMMapMock));
when(loadBalancerVMMapMock.getInstanceId()).thenReturn(virtualMachineId);
when(loadBalancingRulesService.removeFromLoadBalancer(anyLong(), any(), any(), eq(true))).thenReturn(true);
when(loadBalancingRulesService.removeFromLoadBalancer(anyLong(), any(), any(), eq(true))).thenReturn(true);
when(asVmGroupMock.getProfileId()).thenReturn(vmProfileId);
when(autoScaleVmProfileDao.findById(vmProfileId)).thenReturn(asVmProfileMock);
when(asVmProfileMock.getExpungeVmGracePeriod()).thenReturn(expungeVmGracePeriod);
when(asVmGroupMock.getProfileId()).thenReturn(vmProfileId);
when(autoScaleVmProfileDao.findById(vmProfileId)).thenReturn(asVmProfileMock);
when(asVmProfileMock.getExpungeVmGracePeriod()).thenReturn(expungeVmGracePeriod);
autoScaleManagerImplSpy.doScaleDown(vmGroupId);
autoScaleManagerImplSpy.doScaleDown(vmGroupId);
Mockito.verify(loadBalancingRulesService).removeFromLoadBalancer(anyLong(), any(), any(), eq(true));
Mockito.verify(loadBalancingRulesService).removeFromLoadBalancer(anyLong(), any(), any(), eq(true));
}
}
@Test
@ -1585,9 +1564,8 @@ public class AutoScaleManagerImplTest {
public void checkAutoScaleVmGroup1() {
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
PowerMockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).checkNetScalerAsGroup(asVmGroupMock);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).checkVirtualRouterAsGroup(asVmGroupMock);
Mockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
Mockito.doNothing().when(autoScaleManagerImplSpy).checkVirtualRouterAsGroup(asVmGroupMock);
autoScaleManagerImplSpy.checkAutoScaleVmGroup(asVmGroupMock);
@ -1599,9 +1577,8 @@ public class AutoScaleManagerImplTest {
public void checkAutoScaleVmGroup2() {
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
PowerMockito.doReturn(Network.Provider.VPCVirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).checkNetScalerAsGroup(asVmGroupMock);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).checkVirtualRouterAsGroup(asVmGroupMock);
Mockito.doReturn(Network.Provider.VPCVirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
Mockito.doNothing().when(autoScaleManagerImplSpy).checkVirtualRouterAsGroup(asVmGroupMock);
autoScaleManagerImplSpy.checkAutoScaleVmGroup(asVmGroupMock);
@ -1613,9 +1590,8 @@ public class AutoScaleManagerImplTest {
public void checkAutoScaleVmGroup3() {
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
when(asVmGroupMock.getLoadBalancerId()).thenReturn(loadBalancerId);
PowerMockito.doReturn(Network.Provider.Netscaler).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).checkNetScalerAsGroup(asVmGroupMock);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).checkVirtualRouterAsGroup(asVmGroupMock);
Mockito.doReturn(Network.Provider.Netscaler).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
Mockito.doNothing().when(autoScaleManagerImplSpy).checkNetScalerAsGroup(asVmGroupMock);
autoScaleManagerImplSpy.checkAutoScaleVmGroup(asVmGroupMock);
@ -1698,7 +1674,6 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupVmMapDao.listByGroup(vmGroupId)).thenReturn(Arrays.asList(autoScaleVmGroupVmMapVOMock));
when(autoScaleVmGroupVmMapVOMock.getInstanceId()).thenReturn(virtualMachineId);
when(userVmDao.findById(virtualMachineId)).thenReturn(userVmMock);
when(userVmMock.getHostId()).thenReturn(null);
Map<Long, List<Long>> result = autoScaleManagerImplSpy.getHostAndVmIdsMap(groupTO);
@ -1743,9 +1718,9 @@ public class AutoScaleManagerImplTest {
Map<String, Integer> countersNumberMap = new HashMap<>();
when(groupTO.getId()).thenReturn(vmGroupId);
when(groupTO.getLoadBalancerId()).thenReturn(loadBalancerId);
PowerMockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).isQuitTimePassForPolicy(policyTO);
PowerMockito.doReturn(AutoScalePolicy.Action.SCALEUP).when(autoScaleManagerImplSpy).checkConditionsForPolicy(countersMap, countersNumberMap, policyTO, Network.Provider.VirtualRouter);
Mockito.doReturn(Network.Provider.VirtualRouter).when(autoScaleManagerImplSpy).getLoadBalancerServiceProvider(loadBalancerId);
Mockito.doReturn(true).when(autoScaleManagerImplSpy).isQuitTimePassForPolicy(policyTO);
Mockito.doReturn(AutoScalePolicy.Action.SCALEUP).when(autoScaleManagerImplSpy).checkConditionsForPolicy(countersMap, countersNumberMap, policyTO, Network.Provider.VirtualRouter);
AutoScalePolicy.Action result = autoScaleManagerImplSpy.getAutoscaleAction(countersMap, countersNumberMap, groupTO);
@ -1815,10 +1790,8 @@ public class AutoScaleManagerImplTest {
ConditionTO conditionTO2 = Mockito.mock(ConditionTO.class);
CounterTO counterTO2 = Mockito.mock(CounterTO.class);
when(conditionTO1.getCounter()).thenReturn(counterTO1);
when(conditionTO2.getCounter()).thenReturn(counterTO2);
when(policyTO.getConditions()).thenReturn(Arrays.asList(conditionTO1, conditionTO2));
when(policyTO.getId()).thenReturn(scaleUpPolicyId);
when(policyTO.getAction()).thenReturn(AutoScalePolicy.Action.SCALEUP);
Long counterId2 = counterId + 1;
Long conditionId2 = conditionId + 1;
@ -1839,9 +1812,7 @@ public class AutoScaleManagerImplTest {
countersNumberMap.put(key2, 1);
when(conditionTO1.getRelationalOperator()).thenReturn(Condition.Operator.LT);
when(conditionTO2.getRelationalOperator()).thenReturn(Condition.Operator.LE);
when(conditionTO1.getThreshold()).thenReturn(40L);
when(conditionTO2.getThreshold()).thenReturn(60L);
AutoScalePolicy.Action result = autoScaleManagerImplSpy.checkConditionsForPolicy(countersMap, countersNumberMap,
policyTO, Network.Provider.VirtualRouter);
@ -1946,7 +1917,7 @@ public class AutoScaleManagerImplTest {
when(asVmGroupMock.getId()).thenReturn(vmGroupId);
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
when(lbRulesMgr.toAutoScaleVmGroupTO(asVmGroupMock)).thenReturn(groupTO);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).isNative(groupTO);
Mockito.doReturn(true).when(autoScaleManagerImplSpy).isNative(groupTO);
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(minMembers);
when(asVmGroupMock.getMinMembers()).thenReturn(minMembers);
@ -1958,16 +1929,15 @@ public class AutoScaleManagerImplTest {
when(userVmMock.getHostId()).thenReturn(hostId);
when(userVmMock.getInstanceName()).thenReturn(vmName);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).setPerformanceMonitorCommandParams(any(), any());
Mockito.doNothing().when(autoScaleManagerImplSpy).setPerformanceMonitorCommandParams(any(), any());
PerformanceMonitorCommand command = Mockito.mock(PerformanceMonitorCommand.class);
PerformanceMonitorAnswer answer = new PerformanceMonitorAnswer(command, true, "result");
when(agentMgr.send(eq(hostId), any(PerformanceMonitorCommand.class))).thenReturn(answer);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).processPerformanceMonitorAnswer(any(), any(), any(), any(), any());
Mockito.doNothing().when(autoScaleManagerImplSpy).processPerformanceMonitorAnswer(any(), any(), any(), any(), any());
PowerMockito.doReturn(AutoScalePolicy.Action.SCALEUP).when(autoScaleManagerImplSpy).getAutoscaleAction(any(), any(), any());
PowerMockito.doNothing().when(autoScaleManagerImplSpy).doScaleUp(vmGroupId, 1);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).cleanupAsVmGroupStatistics(groupTO);
Mockito.doReturn(AutoScalePolicy.Action.SCALEUP).when(autoScaleManagerImplSpy).getAutoscaleAction(any(), any(), any());
Mockito.doNothing().when(autoScaleManagerImplSpy).doScaleUp(vmGroupId, 1);
autoScaleManagerImplSpy.checkNetScalerAsGroup(asVmGroupMock);
@ -2002,10 +1972,10 @@ public class AutoScaleManagerImplTest {
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
when(lbRulesMgr.toAutoScaleVmGroupTO(asVmGroupMock)).thenReturn(groupTO);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).updateCountersMap(any(), any(), any());
PowerMockito.doReturn(AutoScalePolicy.Action.SCALEUP).when(autoScaleManagerImplSpy).getAutoscaleAction(any(), any(), any());
PowerMockito.doNothing().when(autoScaleManagerImplSpy).doScaleUp(vmGroupId, 1);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).cleanupAsVmGroupStatistics(groupTO);
Mockito.doReturn(true).when(autoScaleManagerImplSpy).updateCountersMap(any(), any(), any());
Mockito.doReturn(AutoScalePolicy.Action.SCALEUP).when(autoScaleManagerImplSpy).getAutoscaleAction(any(), any(), any());
Mockito.doNothing().when(autoScaleManagerImplSpy).doScaleUp(vmGroupId, 1);
Mockito.doNothing().when(autoScaleManagerImplSpy).cleanupAsVmGroupStatistics(groupTO);
autoScaleManagerImplSpy.checkVirtualRouterAsGroup(asVmGroupMock);
@ -2018,10 +1988,10 @@ public class AutoScaleManagerImplTest {
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
when(lbRulesMgr.toAutoScaleVmGroupTO(asVmGroupMock)).thenReturn(groupTO);
PowerMockito.doReturn(true).when(autoScaleManagerImplSpy).updateCountersMap(any(), any(), any());
PowerMockito.doReturn(AutoScalePolicy.Action.SCALEDOWN).when(autoScaleManagerImplSpy).getAutoscaleAction(any(), any(), any());
PowerMockito.doNothing().when(autoScaleManagerImplSpy).doScaleDown(vmGroupId);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).cleanupAsVmGroupStatistics(groupTO);
Mockito.doReturn(true).when(autoScaleManagerImplSpy).updateCountersMap(any(), any(), any());
Mockito.doReturn(AutoScalePolicy.Action.SCALEDOWN).when(autoScaleManagerImplSpy).getAutoscaleAction(any(), any(), any());
Mockito.doNothing().when(autoScaleManagerImplSpy).doScaleDown(vmGroupId);
Mockito.doNothing().when(autoScaleManagerImplSpy).cleanupAsVmGroupStatistics(groupTO);
autoScaleManagerImplSpy.checkVirtualRouterAsGroup(asVmGroupMock);
@ -2042,7 +2012,6 @@ public class AutoScaleManagerImplTest {
when(scaleUpConditionTO.getId()).thenReturn(scaleUpConditionId);
when(scaleUpConditionTO.getCounter()).thenReturn(scaleUpCounterTO);
when(scaleUpCounterTO.getId()).thenReturn(scaleUpCounterId);
when(scaleUpCounterTO.getSource()).thenReturn(Counter.Source.CPU);
AutoScalePolicyTO scaleDownPolicyTO = Mockito.mock(AutoScalePolicyTO.class);
when(scaleDownPolicyTO.getId()).thenReturn(scaleDownPolicyId);
@ -2053,7 +2022,6 @@ public class AutoScaleManagerImplTest {
when(scaleDownConditionTO.getId()).thenReturn(scaleDownConditionId);
when(scaleDownConditionTO.getCounter()).thenReturn(scaleDownCounterTO);
when(scaleDownCounterTO.getId()).thenReturn(scaleDownCounterId);
when(scaleDownCounterTO.getSource()).thenReturn(Counter.Source.VIRTUALROUTER);
when(groupTO.getPolicies()).thenReturn(Arrays.asList(scaleUpPolicyTO, scaleDownPolicyTO));
@ -2073,7 +2041,7 @@ public class AutoScaleManagerImplTest {
when(asGroupStatisticsDao.listByVmGroupAndPolicyAndCounter(eq(vmGroupId), eq(scaleUpPolicyId), eq(scaleUpCounterId), any())).thenReturn(stats);
when(asGroupStatisticsDao.listByVmGroupAndPolicyAndCounter(eq(vmGroupId), eq(scaleDownPolicyId), eq(scaleDownCounterId), any())).thenReturn(stats);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).updateCountersMapWithInstantData(any(), any(), any(),
Mockito.doNothing().when(autoScaleManagerImplSpy).updateCountersMapWithInstantData(any(), any(), any(),
any(), any(), any(), any(), any());
Map<String, Double> countersMap = new HashMap<>();
@ -2099,7 +2067,6 @@ public class AutoScaleManagerImplTest {
when(scaleUpConditionTO.getId()).thenReturn(scaleUpConditionId);
when(scaleUpConditionTO.getCounter()).thenReturn(scaleUpCounterTO);
when(scaleUpCounterTO.getId()).thenReturn(scaleUpCounterId);
when(scaleUpCounterTO.getSource()).thenReturn(Counter.Source.VIRTUALROUTER);
when(groupTO.getPolicies()).thenReturn(Arrays.asList(scaleUpPolicyTO));
@ -2108,8 +2075,6 @@ public class AutoScaleManagerImplTest {
.thenReturn(new ArrayList<>());
when(asGroupStatisticsDao.listInactiveByVmGroupAndPolicy(eq(vmGroupId), eq(scaleUpPolicyId), any()))
.thenReturn(new ArrayList<>());
when(asGroupStatisticsDao.listInactiveByVmGroupAndPolicy(eq(vmGroupId), eq(scaleDownPolicyId), any()))
.thenReturn(new ArrayList<>());
List<AutoScaleVmGroupStatisticsVO> stats = new ArrayList<>();
Date timestamp = new Date();
@ -2123,7 +2088,7 @@ public class AutoScaleManagerImplTest {
when(asGroupStatisticsDao.listByVmGroupAndPolicyAndCounter(eq(vmGroupId), eq(scaleUpPolicyId), eq(scaleUpCounterId), any())).thenReturn(stats);
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(1);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).updateCountersMapWithProcessedData(any(), any(), any(), any());
Mockito.doNothing().when(autoScaleManagerImplSpy).updateCountersMapWithProcessedData(any(), any(), any(), any());
Map<String, Double> countersMap = new HashMap<>();
Map<String, Integer> countersNumberMap = new HashMap<>();
@ -2236,8 +2201,8 @@ public class AutoScaleManagerImplTest {
when(autoScaleVmGroupVmMapDao.countAvailableVmsByGroup(vmGroupId)).thenReturn(minMembers);
when(lbRulesMgr.toAutoScaleVmGroupTO(asVmGroupMock)).thenReturn(groupTO);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).getVmStatsFromHosts(groupTO);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).getNetworkStatsFromVirtualRouter(groupTO);
Mockito.doNothing().when(autoScaleManagerImplSpy).getVmStatsFromHosts(groupTO);
Mockito.doNothing().when(autoScaleManagerImplSpy).getNetworkStatsFromVirtualRouter(groupTO);
autoScaleManagerImplSpy.monitorVirtualRouterAsGroup(asVmGroupMock);
@ -2258,12 +2223,12 @@ public class AutoScaleManagerImplTest {
policyCountersMap.put(scaleDownPolicyId, Arrays.asList(scaleDownCounter));
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
PowerMockito.doReturn(hostAndVmIdsMap).when(autoScaleManagerImplSpy).getHostAndVmIdsMap(groupTO);
PowerMockito.doReturn(policyCountersMap).when(autoScaleManagerImplSpy).getPolicyCounters(groupTO);
Mockito.doReturn(hostAndVmIdsMap).when(autoScaleManagerImplSpy).getHostAndVmIdsMap(groupTO);
Mockito.doReturn(policyCountersMap).when(autoScaleManagerImplSpy).getPolicyCounters(groupTO);
Map<Long, VmStatsEntry> vmStatsById = new HashMap<>();
PowerMockito.doReturn(vmStatsById).doReturn(vmStatsById).when(autoScaleManagerImplSpy).getVmStatsByIdFromHost(anyLong(), any());
PowerMockito.doNothing().doNothing().when(autoScaleManagerImplSpy).processVmStatsByIdFromHost(any(), any(), any(), any());
Mockito.doReturn(vmStatsById).doReturn(vmStatsById).when(autoScaleManagerImplSpy).getVmStatsByIdFromHost(anyLong(), any());
Mockito.doNothing().doNothing().when(autoScaleManagerImplSpy).processVmStatsByIdFromHost(any(), any(), any(), any());
autoScaleManagerImplSpy.getVmStatsFromHosts(groupTO);
@ -2274,8 +2239,6 @@ public class AutoScaleManagerImplTest {
@Test
public void getVmStatsByIdFromHost() {
List<Long> vmIds = Mockito.mock(ArrayList.class);
Map<Long, VmStatsEntry> vmStatsById = Mockito.mock(HashMap.class);
Mockito.doReturn(vmStatsById).when(virtualMachineManager).getVirtualMachineStatistics(anyLong(), anyString(), anyList());
Map<Long, ? extends VmStats> result = autoScaleManagerImplSpy.getVmStatsByIdFromHost(-1L, vmIds);
@ -2332,12 +2295,12 @@ public class AutoScaleManagerImplTest {
public void getNetworkStatsFromVirtualRouterWithoutRouter() {
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
when(groupTO.getLoadBalancerId()).thenReturn(loadBalancerId);
PowerMockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
Mockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
when(networkMock.getId()).thenReturn(networkId);
Pair<String, Integer> publicIpAddr = new Pair<>(ipAddress, memberPort);
PowerMockito.doReturn(publicIpAddr).when(autoScaleManagerImplSpy).getPublicIpAndPort(loadBalancerId);
Mockito.doReturn(publicIpAddr).when(autoScaleManagerImplSpy).getPublicIpAndPort(loadBalancerId);
when(routerDao.listByNetworkAndRole(networkId, VirtualRouter.Role.VIRTUAL_ROUTER)).thenReturn(new ArrayList<>());
PowerMockito.doNothing().when(autoScaleManagerImplSpy).processGetAutoScaleMetricsAnswer(any(), any(), nullable(Long.class));
Mockito.doNothing().when(autoScaleManagerImplSpy).processGetAutoScaleMetricsAnswer(any(), any(), nullable(Long.class));
autoScaleManagerImplSpy.getNetworkStatsFromVirtualRouter(groupTO);
@ -2348,22 +2311,22 @@ public class AutoScaleManagerImplTest {
public void getNetworkStatsFromVirtualRouterWithOneRouter() {
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
when(groupTO.getLoadBalancerId()).thenReturn(loadBalancerId);
PowerMockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
Mockito.doReturn(networkMock).when(autoScaleManagerImplSpy).getNetwork(loadBalancerId);
when(networkMock.getId()).thenReturn(networkId);
Pair<String, Integer> publicIpAddr = new Pair<>(ipAddress, memberPort);
PowerMockito.doReturn(publicIpAddr).when(autoScaleManagerImplSpy).getPublicIpAndPort(loadBalancerId);
Mockito.doReturn(publicIpAddr).when(autoScaleManagerImplSpy).getPublicIpAndPort(loadBalancerId);
when(routerDao.listByNetworkAndRole(networkId, VirtualRouter.Role.VIRTUAL_ROUTER)).thenReturn(Arrays.asList(domainRouterMock));
when(domainRouterMock.getState()).thenReturn(VirtualMachine.State.Running);
when(domainRouterMock.getId()).thenReturn(domainRouterId);
when(domainRouterMock.getHostId()).thenReturn(hostId);
List<VirtualRouterAutoScale.AutoScaleMetrics> metrics = Mockito.mock(ArrayList.class);
PowerMockito.doReturn(metrics).when(autoScaleManagerImplSpy).setGetAutoScaleMetricsCommandMetrics(groupTO);
Mockito.doReturn(metrics).when(autoScaleManagerImplSpy).setGetAutoScaleMetricsCommandMetrics(groupTO);
GetAutoScaleMetricsCommand command = Mockito.mock(GetAutoScaleMetricsCommand.class);
List<VirtualRouterAutoScale.AutoScaleMetricsValue> values = Mockito.mock(ArrayList.class);
GetAutoScaleMetricsAnswer answer = new GetAutoScaleMetricsAnswer(command, true, values);
when(agentMgr.easySend(eq(hostId), any(GetAutoScaleMetricsCommand.class))).thenReturn(answer);
PowerMockito.doNothing().when(autoScaleManagerImplSpy).processGetAutoScaleMetricsAnswer(any(), any(), nullable(Long.class));
Mockito.doNothing().when(autoScaleManagerImplSpy).processGetAutoScaleMetricsAnswer(any(), any(), nullable(Long.class));
autoScaleManagerImplSpy.getNetworkStatsFromVirtualRouter(groupTO);
@ -2381,7 +2344,6 @@ public class AutoScaleManagerImplTest {
when(scaleUpPolicyTO.getId()).thenReturn(scaleUpPolicyId);
when(scaleUpPolicyTO.getConditions()).thenReturn(Arrays.asList(scaleUpConditionTO));
when(scaleUpConditionTO.getCounter()).thenReturn(scaleUpCounterTO);
when(scaleUpCounterTO.getSource()).thenReturn(Counter.Source.CPU);
when(scaleUpCounterTO.getProvider()).thenReturn(Network.Provider.VirtualRouter.getName());
when(scaleUpCounterTO.getValue()).thenReturn(VirtualRouterAutoScaleCounter.NETWORK_RECEIVED_AVERAGE_MBPS.toString());
@ -2391,7 +2353,6 @@ public class AutoScaleManagerImplTest {
when(scaleDownPolicyTO.getId()).thenReturn(scaleDownPolicyId);
when(scaleDownPolicyTO.getConditions()).thenReturn(Arrays.asList(scaleDownConditionTO));
when(scaleDownConditionTO.getCounter()).thenReturn(scaleDownCounterTO);
when(scaleDownCounterTO.getSource()).thenReturn(Counter.Source.VIRTUALROUTER);
when(scaleDownCounterTO.getProvider()).thenReturn(Network.Provider.VirtualRouter.getName());
when(scaleDownCounterTO.getValue()).thenReturn(VirtualRouterAutoScaleCounter.NETWORK_TRANSMIT_AVERAGE_MBPS.toString());
@ -2413,7 +2374,7 @@ public class AutoScaleManagerImplTest {
policyCountersMap.put(scaleDownPolicyId, Arrays.asList(scaleDownCounter));
AutoScaleVmGroupTO groupTO = Mockito.mock(AutoScaleVmGroupTO.class);
PowerMockito.doReturn(policyCountersMap).when(autoScaleManagerImplSpy).getPolicyCounters(groupTO);
Mockito.doReturn(policyCountersMap).when(autoScaleManagerImplSpy).getPolicyCounters(groupTO);
when(scaleUpCounter.getSource()).thenReturn(Counter.Source.VIRTUALROUTER);
when(scaleUpCounter.getId()).thenReturn(counterId);
@ -2449,7 +2410,6 @@ public class AutoScaleManagerImplTest {
}
@Test
@PrepareForTest(Executors.class)
public void scheduleMonitorTasks() {
when(autoScaleVmGroupDao.listAll()).thenReturn(Arrays.asList(asVmGroupMock));
when(asVmGroupMock.getState()).thenReturn(AutoScaleVmGroup.State.ENABLED);
@ -2460,13 +2420,14 @@ public class AutoScaleManagerImplTest {
ReflectionTestUtils.setField(autoScaleManagerImplSpy, "vmGroupMonitorMaps", vmGroupMonitorMaps);
when(autoScaleVmGroupDao.findById(vmGroupId)).thenReturn(asVmGroupMock);
ScheduledExecutorService vmGroupExecutor = Mockito.mock(ScheduledExecutorService.class);
PowerMockito.mockStatic(Executors.class);
when(Executors.newScheduledThreadPool(eq(1), any())).thenReturn(vmGroupExecutor);
try (MockedStatic<Executors> ignored = Mockito.mockStatic(Executors.class)) {
when(Executors.newScheduledThreadPool(eq(1), any())).thenReturn(vmGroupExecutor);
autoScaleManagerImplSpy.scheduleMonitorTasks();
autoScaleManagerImplSpy.scheduleMonitorTasks();
Assert.assertEquals(1, vmGroupMonitorMaps.size());
Assert.assertNotNull(vmGroupMonitorMaps.get(vmGroupId));
Assert.assertEquals(1, vmGroupMonitorMaps.size());
Assert.assertNotNull(vmGroupMonitorMaps.get(vmGroupId));
}
}
@Test
@ -2474,7 +2435,7 @@ public class AutoScaleManagerImplTest {
Map<Long, ScheduledExecutorService> vmGroupMonitorMaps = new HashMap<>();
ScheduledExecutorService vmGroupExecutor = Mockito.mock(ScheduledExecutorService.class);
vmGroupMonitorMaps.put(vmGroupId, vmGroupExecutor);
PowerMockito.doNothing().when(vmGroupExecutor).shutdown();
Mockito.doNothing().when(vmGroupExecutor).shutdown();
ReflectionTestUtils.setField(autoScaleManagerImplSpy, "vmGroupMonitorMaps", vmGroupMonitorMaps);
@ -2508,7 +2469,7 @@ public class AutoScaleManagerImplTest {
@Test
public void destroyVm() {
when(userVmDao.findById(virtualMachineId)).thenReturn(userVmMock);
PowerMockito.doReturn(true).when(userVmMgr).expunge(eq(userVmMock));
Mockito.doReturn(true).when(userVmMgr).expunge(eq(userVmMock));
autoScaleManagerImplSpy.destroyVm(virtualMachineId);

186
server/src/test/java/com/cloud/network/element/ConfigDriveNetworkElementTest.java
View File

@ -16,58 +16,15 @@
// under the License.
package com.cloud.network.element;
import static org.hamcrest.Matchers.hasEntry;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.engine.subsystem.api.storage.EndPoint;
import org.apache.cloudstack.engine.subsystem.api.storage.EndPointSelector;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.storage.configdrive.ConfigDrive;
import org.apache.cloudstack.storage.configdrive.ConfigDriveBuilder;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.reflections.ReflectionUtils;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.HandleConfigDriveIsoAnswer;
import com.cloud.agent.api.HandleConfigDriveIsoCommand;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.deploy.DeployDestination;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.host.HostVO;
@ -103,9 +60,44 @@ import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.UserVmDetailsDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.google.common.collect.Maps;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.engine.subsystem.api.storage.EndPoint;
import org.apache.cloudstack.engine.subsystem.api.storage.EndPointSelector;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.storage.configdrive.ConfigDrive;
import org.apache.cloudstack.storage.configdrive.ConfigDriveBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest(CallContext.class)
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import static org.hamcrest.Matchers.hasEntry;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ConfigDriveNetworkElementTest {
public static final String CLOUD_ID = "xx";
@ -157,28 +149,30 @@ public class ConfigDriveNetworkElementTest {
@Mock private CallContext callContextMock;
@Mock private DomainVO domainVO;
@InjectMocks private final ConfigDriveNetworkElement _configDrivesNetworkElement = new ConfigDriveNetworkElement();
@InjectMocks @Spy private NetworkModelImpl _networkModel = new NetworkModelImpl();
@Spy @InjectMocks
private ConfigDriveNetworkElement _configDrivesNetworkElement = new ConfigDriveNetworkElement();
@InjectMocks @Spy private NetworkModelImpl _networkModel;
private AutoCloseable closeable;
@Before
public void setUp() throws NoSuchFieldException, IllegalAccessException {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
_configDrivesNetworkElement._networkModel = _networkModel;
_configDrivesNetworkElement._networkMgr = _networkModel;
when(_dataStoreMgr.getImageStoreWithFreeCapacity(DATACENTERID)).thenReturn(dataStore);
when(_ep.select(dataStore)).thenReturn(endpoint);
when(_vmDao.findById(VMID)).thenReturn(virtualMachine);
when(_vmInstanceDao.findById(VMID)).thenReturn(virtualMachine);
when(_dcDao.findById(DATACENTERID)).thenReturn(dataCenterVO);
when(_hostDao.findById(HOSTID)).thenReturn(hostVO);
when(_domainDao.findById(DOMAINID)).thenReturn(domainVO);
doReturn(nic).when(_networkModel).getDefaultNic(VMID);
when(_serviceOfferingDao.findByIdIncludingRemoved(VMID, SOID)).thenReturn(serviceOfferingVO);
when(_guestOSDao.findById(anyLong())).thenReturn(guestOSVO);
when(_guestOSCategoryDao.findById(anyLong())).thenReturn(guestOSCategoryVo);
when(_guestOSDao.findById(Mockito.anyLong())).thenReturn(guestOSVO);
when(_guestOSCategoryDao.findById(Mockito.anyLong())).thenReturn(guestOSCategoryVo);
when(_configDao.getValue("cloud.identifier")).thenReturn(CLOUD_ID);
when(network.getDataCenterId()).thenReturn(DATACENTERID);
when(guestOSCategoryVo.getName()).thenReturn("Linux");
when(dataCenterVO.getName()).thenReturn(ZONENAME);
when(serviceOfferingVO.getDisplayText()).thenReturn(VMOFFERING);
@ -197,19 +191,23 @@ public class ConfigDriveNetworkElementTest {
when(deployDestination.getHost()).thenReturn(hostVO);
when(deployDestination.getDataCenter()).thenReturn(dataCenter);
when(hostVO.getId()).thenReturn(HOSTID);
when(nic.isDefaultNic()).thenReturn(true);
when(nic.getNetworkId()).thenReturn(NETWORK_ID);
when(network.getId()).thenReturn(NETWORK_ID);
when(_networkModel.getNetwork(NETWORK_ID)).thenReturn(network);
//when(_networkModel.getUserDataUpdateProvider(network)).thenReturn(_configDrivesNetworkElement);
when(_ntwkSrvcDao.getProviderForServiceInNetwork(NETWORK_ID, Network.Service.UserData)).thenReturn(_configDrivesNetworkElement.getProvider().getName());
doReturn(_configDrivesNetworkElement.getProvider().getName()).when(_ntwkSrvcDao).getProviderForServiceInNetwork(NETWORK_ID, Network.Service.UserData);
_networkModel.setNetworkElements(Arrays.asList(_configDrivesNetworkElement));
_networkModel.start();
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void testCanHandle() throws InsufficientCapacityException, ResourceUnavailableException {
final NetworkOfferingVO ntwkoffer = mock(NetworkOfferingVO.class);
@ -221,7 +219,6 @@ public class ConfigDriveNetworkElementTest {
}
@Test
@SuppressWarnings("unchecked")
public void testExpunge() throws NoTransitionException, NoSuchFieldException, IllegalAccessException {
final StateMachine2<VirtualMachine.State, VirtualMachine.Event, VirtualMachine> stateMachine = VirtualMachine.State.getStateMachine();
@ -238,13 +235,13 @@ public class ConfigDriveNetworkElementTest {
when(_vmInstanceDao.updateState(VirtualMachine.State.Stopped, VirtualMachine.Event.ExpungeOperation, VirtualMachine.State.Expunging, virtualMachine, null)).thenReturn(true);
final HandleConfigDriveIsoAnswer answer = mock(HandleConfigDriveIsoAnswer.class);
when(agentManager.easySend(anyLong(), any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
when(agentManager.easySend(Mockito.anyLong(), Mockito.any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
when(answer.getResult()).thenReturn(true);
stateMachine.transitTo(virtualMachine, VirtualMachine.Event.ExpungeOperation, null, _vmInstanceDao);
ArgumentCaptor<HandleConfigDriveIsoCommand> commandCaptor = ArgumentCaptor.forClass(HandleConfigDriveIsoCommand.class);
verify(agentManager, times(1)).easySend(anyLong(), commandCaptor.capture());
verify(agentManager, times(1)).easySend(Mockito.anyLong(), commandCaptor.capture());
HandleConfigDriveIsoCommand deleteCommand = commandCaptor.getValue();
assertThat(deleteCommand.isCreate(), is(false));
@ -253,9 +250,6 @@ public class ConfigDriveNetworkElementTest {
@Test
public void testRelease() {
final Answer answer = mock(Answer.class);
when(agentManager.easySend(anyLong(), any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
when(answer.getResult()).thenReturn(true);
VirtualMachineProfile profile = new VirtualMachineProfileImpl(virtualMachine, null, serviceOfferingVO, null, null);
assertTrue(_configDrivesNetworkElement.release(network, nicp, profile, null));
}
@ -266,46 +260,42 @@ public class ConfigDriveNetworkElementTest {
}
@Test
@SuppressWarnings("unchecked")
@PrepareForTest({ConfigDriveBuilder.class, CallContext.class})
public void testAddPasswordAndUserData() throws Exception {
PowerMockito.mockStatic(ConfigDriveBuilder.class);
PowerMockito.mockStatic(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();
Method method = ReflectionUtils.getMethods(ConfigDriveBuilder.class, ReflectionUtils.withName("buildConfigDrive")).iterator().next();
PowerMockito.when(ConfigDriveBuilder.class, method).withArguments(Mockito.anyListOf(String[].class), Mockito.anyString(), Mockito.anyString(), Mockito.anyMap()).thenReturn("content");
try (MockedStatic<ConfigDriveBuilder> ignored1 = Mockito.mockStatic(ConfigDriveBuilder.class); MockedStatic<CallContext> ignored2 = Mockito.mockStatic(CallContext.class)) {
Mockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();
Mockito.when(ConfigDriveBuilder.buildConfigDrive(Mockito.anyListOf(String[].class), Mockito.anyString(), Mockito.anyString(), Mockito.anyMap())).thenReturn("content");
final HandleConfigDriveIsoAnswer answer = mock(HandleConfigDriveIsoAnswer.class);
final UserVmDetailVO userVmDetailVO = mock(UserVmDetailVO.class);
when(agentManager.easySend(anyLong(), any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
when(answer.getResult()).thenReturn(true);
when(answer.getConfigDriveLocation()).thenReturn(NetworkElement.Location.PRIMARY);
when(network.getTrafficType()).thenReturn(Networks.TrafficType.Guest);
when(virtualMachine.getState()).thenReturn(VirtualMachine.State.Stopped);
when(virtualMachine.getUuid()).thenReturn("vm-uuid");
when(userVmDetailVO.getValue()).thenReturn(PUBLIC_KEY);
when(nicp.getIPv4Address()).thenReturn("192.168.111.111");
when(_userVmDetailsDao.findDetail(anyLong(), anyString())).thenReturn(userVmDetailVO);
when(_ipAddressDao.findByAssociatedVmId(VMID)).thenReturn(publicIp);
when(publicIp.getAddress()).thenReturn(new Ip("7.7.7.7"));
when(_hostDao.findById(virtualMachine.getHostId())).thenReturn(hostVO);
when(_hostDao.findById(virtualMachine.getHostId()).getName()).thenReturn("dest-hyp-host-name");
final HandleConfigDriveIsoAnswer answer = mock(HandleConfigDriveIsoAnswer.class);
final UserVmDetailVO userVmDetailVO = mock(UserVmDetailVO.class);
when(agentManager.easySend(Mockito.anyLong(), Mockito.any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
when(answer.getResult()).thenReturn(true);
when(answer.getConfigDriveLocation()).thenReturn(NetworkElement.Location.PRIMARY);
when(network.getTrafficType()).thenReturn(Networks.TrafficType.Guest);
when(virtualMachine.getUuid()).thenReturn("vm-uuid");
when(userVmDetailVO.getValue()).thenReturn(PUBLIC_KEY);
when(nicp.getIPv4Address()).thenReturn("192.168.111.111");
when(_userVmDetailsDao.findDetail(Mockito.anyLong(), Mockito.anyString())).thenReturn(userVmDetailVO);
when(_ipAddressDao.findByAssociatedVmId(VMID)).thenReturn(publicIp);
when(publicIp.getAddress()).thenReturn(new Ip("7.7.7.7"));
when(_hostDao.findById(virtualMachine.getHostId())).thenReturn(hostVO);
when(_hostDao.findById(virtualMachine.getHostId()).getName()).thenReturn("dest-hyp-host-name");
Map<VirtualMachineProfile.Param, Object> parms = Maps.newHashMap();
parms.put(VirtualMachineProfile.Param.VmPassword, PASSWORD);
parms.put(VirtualMachineProfile.Param.VmSshPubKey, PUBLIC_KEY);
VirtualMachineProfile profile = new VirtualMachineProfileImpl(virtualMachine, null, serviceOfferingVO, null, parms);
profile.setConfigDriveLabel("testlabel");
assertTrue(_configDrivesNetworkElement.addPasswordAndUserdata(
network, nicp, profile, deployDestination, null));
Map<VirtualMachineProfile.Param, Object> parms = Maps.newHashMap();
parms.put(VirtualMachineProfile.Param.VmPassword, PASSWORD);
parms.put(VirtualMachineProfile.Param.VmSshPubKey, PUBLIC_KEY);
VirtualMachineProfile profile = new VirtualMachineProfileImpl(virtualMachine, null, serviceOfferingVO, null, parms);
profile.setConfigDriveLabel("testlabel");
assertTrue(_configDrivesNetworkElement.addPasswordAndUserdata(
network, nicp, profile, deployDestination, null));
ArgumentCaptor<HandleConfigDriveIsoCommand> commandCaptor = ArgumentCaptor.forClass(HandleConfigDriveIsoCommand.class);
verify(agentManager, times(1)).easySend(anyLong(), commandCaptor.capture());
HandleConfigDriveIsoCommand createCommand = commandCaptor.getValue();
ArgumentCaptor<HandleConfigDriveIsoCommand> commandCaptor = ArgumentCaptor.forClass(HandleConfigDriveIsoCommand.class);
verify(agentManager, times(1)).easySend(Mockito.anyLong(), commandCaptor.capture());
HandleConfigDriveIsoCommand createCommand = commandCaptor.getValue();
assertTrue(createCommand.isCreate());
assertTrue(createCommand.getIsoData().length() > 0);
assertTrue(createCommand.getIsoFile().equals(ConfigDrive.createConfigDrivePath(profile.getInstanceName())));
assertTrue(createCommand.isCreate());
assertTrue(createCommand.getIsoData().length() > 0);
assertTrue(createCommand.getIsoFile().equals(ConfigDrive.createConfigDrivePath(profile.getInstanceName())));
}
}
}

59
server/src/test/java/com/cloud/network/element/VirtualRouterElementTest.java
View File

@ -16,36 +16,6 @@
// under the License.
package com.cloud.network.element;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import com.cloud.network.as.AutoScaleCounter;
import com.cloud.network.as.AutoScaleCounter.AutoScaleCounterType;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.network.router.deployment.RouterDeploymentDefinitionBuilder;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import com.cloud.cluster.dao.ManagementServerHostDao;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.dc.DataCenter;
@ -69,6 +39,8 @@ import com.cloud.network.NetworkModel;
import com.cloud.network.NetworkModelImpl;
import com.cloud.network.Networks.TrafficType;
import com.cloud.network.VirtualRouterProvider.Type;
import com.cloud.network.as.AutoScaleCounter;
import com.cloud.network.as.AutoScaleCounter.AutoScaleCounterType;
import com.cloud.network.dao.FirewallRulesDao;
import com.cloud.network.dao.IPAddressDao;
import com.cloud.network.dao.LoadBalancerDao;
@ -124,6 +96,33 @@ import com.cloud.vm.dao.NicIpAliasDao;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.UserVmDetailsDao;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.network.router.deployment.RouterDeploymentDefinitionBuilder;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class VirtualRouterElementTest {

41
server/src/test/java/com/cloud/network/element/VpcVirtualRouterElementTest.java
View File

@ -16,27 +16,6 @@
// under the License.
package com.cloud.network.element;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import org.apache.cloudstack.network.topology.AdvancedNetworkTopology;
import org.apache.cloudstack.network.topology.BasicNetworkTopology;
import org.apache.cloudstack.network.topology.NetworkTopologyContext;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.exception.ResourceUnavailableException;
@ -47,6 +26,26 @@ import com.cloud.network.vpc.Vpc;
import com.cloud.utils.db.EntityManager;
import com.cloud.vm.DomainRouterVO;
import com.cloud.vm.dao.DomainRouterDao;
import org.apache.cloudstack.network.topology.AdvancedNetworkTopology;
import org.apache.cloudstack.network.topology.BasicNetworkTopology;
import org.apache.cloudstack.network.topology.NetworkTopologyContext;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class VpcVirtualRouterElementTest {

47
server/src/test/java/com/cloud/network/firewall/FirewallManagerTest.java
View File

@ -17,25 +17,26 @@
package com.cloud.network.firewall;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.spy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import com.cloud.exception.NetworkRuleConflictException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.IpAddressManager;
import com.cloud.network.Network;
import com.cloud.network.NetworkModel;
import com.cloud.network.NetworkRuleApplier;
import com.cloud.network.dao.FirewallRulesDao;
import com.cloud.network.element.FirewallServiceProvider;
import com.cloud.network.element.VirtualRouterElement;
import com.cloud.network.element.VpcVirtualRouterElement;
import com.cloud.network.rules.FirewallManager;
import com.cloud.network.rules.FirewallRule;
import com.cloud.network.rules.FirewallRule.Purpose;
import com.cloud.network.rules.FirewallRuleVO;
import com.cloud.network.vpc.VpcManager;
import com.cloud.user.AccountManager;
import com.cloud.user.DomainManager;
import com.cloud.utils.component.ComponentContext;
import junit.framework.Assert;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Ignore;
@ -46,20 +47,16 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.IpAddressManager;
import com.cloud.network.Network;
import com.cloud.network.NetworkRuleApplier;
import com.cloud.network.element.FirewallServiceProvider;
import com.cloud.network.element.VirtualRouterElement;
import com.cloud.network.element.VpcVirtualRouterElement;
import com.cloud.network.rules.FirewallManager;
import com.cloud.network.rules.FirewallRule;
import com.cloud.network.rules.FirewallRule.Purpose;
import com.cloud.network.rules.FirewallRuleVO;
import com.cloud.utils.component.ComponentContext;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class FirewallManagerTest {

27
server/src/test/java/com/cloud/network/guru/DirectNetworkGuruTest.java
View File

@ -16,20 +16,6 @@
// under the License.
package com.cloud.network.guru;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import com.cloud.dc.DataCenter.NetworkType;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
@ -47,6 +33,19 @@ import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;
import com.cloud.user.Account;
import com.cloud.utils.Pair;
import com.cloud.vm.NicProfile;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
public class DirectNetworkGuruTest {

27
server/src/test/java/com/cloud/network/guru/ExternalGuestNetworkGuruTest.java
View File

@ -16,18 +16,6 @@
// under the License.
package com.cloud.network.guru;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
@ -41,11 +29,19 @@ import com.cloud.network.dao.PhysicalNetworkVO;
import com.cloud.offering.NetworkOffering;
import com.cloud.user.Account;
import com.cloud.utils.Pair;
import com.cloud.utils.component.ComponentContext;
import com.cloud.vm.NicProfile;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ComponentContext.class)
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@RunWith(MockitoJUnitRunner.class)
public class ExternalGuestNetworkGuruTest {
@Mock
NetworkModel networkModel;
@ -71,7 +67,6 @@ public class ExternalGuestNetworkGuruTest {
Mockito.when(zone.getNetworkType()).thenReturn(DataCenter.NetworkType.Advanced);
Mockito.when(dataCenterDao.findById(Mockito.anyLong())).thenReturn(zone);
PhysicalNetworkVO physicalNetwork = Mockito.mock(PhysicalNetworkVO.class);
Mockito.when(physicalNetwork.getId()).thenReturn(1L);
Mockito.when(physicalNetworkDao.findById(Mockito.anyLong())).thenReturn(physicalNetwork);
DeploymentPlan plan = Mockito.mock(DeploymentPlan.class);
Network network = Mockito.mock(Network.class);

12
server/src/test/java/com/cloud/network/lb/AssignLoadBalancerTest.java
View File

@ -17,10 +17,10 @@
package com.cloud.network.lb;
import com.cloud.domain.DomainVO;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.network.Network;
import com.cloud.network.NetworkModelImpl;
@ -58,11 +58,11 @@ import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import java.util.UUID;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyLong;

33
server/src/test/java/com/cloud/network/lb/UpdateLoadBalancerTest.java
View File

@ -16,23 +16,6 @@
// under the License.
package com.cloud.network.lb;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.UUID;
import org.apache.cloudstack.api.command.user.loadbalancer.UpdateLoadBalancerRuleCmd;
import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mockito;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceAllocationException;
@ -55,6 +38,22 @@ import com.cloud.user.AccountVO;
import com.cloud.user.MockAccountManagerImpl;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import org.apache.cloudstack.api.command.user.loadbalancer.UpdateLoadBalancerRuleCmd;
import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mockito;
import java.util.ArrayList;
import java.util.UUID;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
public class UpdateLoadBalancerTest {

4
server/src/test/java/com/cloud/network/router/CommandSetupHelperTest.java
View File

@ -21,12 +21,12 @@ import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
@RunWith(PowerMockRunner.class)
@RunWith(MockitoJUnitRunner.class)
public class CommandSetupHelperTest {
@InjectMocks

29
server/src/test/java/com/cloud/network/router/NetworkHelperImplTest.java
View File

@ -16,6 +16,20 @@
// under the License.
package com.cloud.network.router;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.Command;
import com.cloud.agent.manager.Commands;
import com.cloud.exception.AgentUnavailableException;
import com.cloud.exception.OperationTimedoutException;
import com.cloud.exception.ResourceUnavailableException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doReturn;
@ -26,21 +40,6 @@ import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.Command;
import com.cloud.agent.manager.Commands;
import com.cloud.exception.AgentUnavailableException;
import com.cloud.exception.OperationTimedoutException;
import com.cloud.exception.ResourceUnavailableException;
@RunWith(MockitoJUnitRunner.class)
public class NetworkHelperImplTest {

27
server/src/test/java/com/cloud/network/router/RouterControlHelperTest.java
View File

@ -16,20 +16,6 @@
// under the License.
package com.cloud.network.router;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.network.Networks.TrafficType;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.NetworkVO;
@ -37,6 +23,19 @@ import com.cloud.vm.DomainRouterVO;
import com.cloud.vm.NicVO;
import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.NicDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class RouterControlHelperTest {

43
server/src/test/java/com/cloud/network/router/VirtualNetworkApplianceManagerImplTest.java
View File

@ -16,28 +16,6 @@
// under the License.
package com.cloud.network.router;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.utils.identity.ManagementServerNode;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.CheckS2SVpnConnectionsAnswer;
import com.cloud.agent.api.CheckS2SVpnConnectionsCommand;
@ -90,6 +68,27 @@ import com.cloud.vm.dao.NicIpAliasDao;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.UserVmDetailsDao;
import com.cloud.vm.dao.VMInstanceDao;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.utils.identity.ManagementServerNode;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;

27
server/src/test/java/com/cloud/network/security/SecurityGroupManagerImpl2Test.java
View File

@ -16,16 +16,10 @@
// under the License.
package com.cloud.network.security;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import javax.sql.DataSource;
import com.cloud.utils.Profiler;
import com.cloud.utils.PropertiesUtil;
import com.cloud.utils.component.ComponentContext;
import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@ -34,11 +28,14 @@ import org.mockito.Mockito;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.cloud.utils.Profiler;
import com.cloud.utils.PropertiesUtil;
import com.cloud.utils.component.ComponentContext;
import junit.framework.TestCase;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/SecurityGroupManagerTestContext.xml")

11
server/src/test/java/com/cloud/network/security/SecurityGroupManagerImplTest.java
View File

@ -17,20 +17,17 @@
package com.cloud.network.security;
import java.util.Set;
import java.util.TreeSet;
import javax.inject.Inject;
import com.cloud.network.security.SecurityGroupManagerImpl.CidrComparator;
import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.cloud.network.security.SecurityGroupManagerImpl.CidrComparator;
import javax.inject.Inject;
import java.util.Set;
import java.util.TreeSet;
/**
* @author daan

34
server/src/test/java/com/cloud/network/security/SecurityGroupManagerTestConfiguration.java
View File

@ -17,24 +17,6 @@
package com.cloud.network.security;
import java.io.IOException;
import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDaoImpl;
import org.apache.cloudstack.framework.config.dao.ConfigurationGroupDaoImpl;
import org.apache.cloudstack.framework.config.dao.ConfigurationSubGroupDaoImpl;
import org.apache.cloudstack.test.utils.SpringUtils;
import com.cloud.agent.AgentManager;
import com.cloud.api.query.dao.SecurityGroupJoinDaoImpl;
import com.cloud.cluster.agentlb.dao.HostTransferMapDaoImpl;
@ -70,6 +52,22 @@ import com.cloud.vm.dao.NicDaoImpl;
import com.cloud.vm.dao.UserVmDaoImpl;
import com.cloud.vm.dao.UserVmDetailsDaoImpl;
import com.cloud.vm.dao.VMInstanceDaoImpl;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDaoImpl;
import org.apache.cloudstack.framework.config.dao.ConfigurationGroupDaoImpl;
import org.apache.cloudstack.framework.config.dao.ConfigurationSubGroupDaoImpl;
import org.apache.cloudstack.test.utils.SpringUtils;
import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import java.io.IOException;
@Configuration
@ComponentScan(basePackageClasses = {SecurityGroupRulesDaoImpl.class, UserVmDaoImpl.class, AccountDaoImpl.class, ConfigurationDaoImpl.class, ConfigurationGroupDaoImpl.class,

7
server/src/test/java/com/cloud/network/security/SecurityGroupQueueTest.java
View File

@ -16,15 +16,14 @@
// under the License.
package com.cloud.network.security;
import com.cloud.utils.Profiler;
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import junit.framework.TestCase;
import com.cloud.utils.Profiler;
public class SecurityGroupQueueTest extends TestCase {
public final static SecurityGroupWorkQueue queue = new LocalSecurityGroupWorkQueue();

7
server/src/test/java/com/cloud/network/vpc/NetworkACLManagerImplTest.java
View File

@ -17,6 +17,9 @@
package com.cloud.network.vpc;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.vpc.NetworkACLItem.State;
import com.cloud.utils.exception.CloudRuntimeException;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -26,10 +29,6 @@ import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.vpc.NetworkACLItem.State;
import com.cloud.utils.exception.CloudRuntimeException;
@RunWith(MockitoJUnitRunner.class)
public class NetworkACLManagerImplTest {

67
server/src/test/java/com/cloud/network/vpc/NetworkACLManagerTest.java
View File

@ -15,22 +15,27 @@
package com.cloud.network.vpc;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.inject.Inject;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.network.Network;
import com.cloud.network.NetworkModel;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.NetworkServiceMapDao;
import com.cloud.network.dao.NetworkVO;
import com.cloud.network.element.NetworkACLServiceProvider;
import com.cloud.network.vpc.NetworkACLItem.State;
import com.cloud.network.vpc.dao.NetworkACLDao;
import com.cloud.network.vpc.dao.VpcGatewayDao;
import com.cloud.offerings.dao.NetworkOfferingDao;
import com.cloud.server.ResourceTag;
import com.cloud.tags.dao.ResourceTagDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import junit.framework.TestCase;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.messagebus.MessageBus;
@ -52,27 +57,19 @@ import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.network.Network;
import com.cloud.network.NetworkModel;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.NetworkServiceMapDao;
import com.cloud.network.dao.NetworkVO;
import com.cloud.network.element.NetworkACLServiceProvider;
import com.cloud.network.vpc.NetworkACLItem.State;
import com.cloud.network.vpc.dao.NetworkACLDao;
import com.cloud.network.vpc.dao.VpcGatewayDao;
import com.cloud.offerings.dao.NetworkOfferingDao;
import com.cloud.tags.dao.ResourceTagDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;
import javax.inject.Inject;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import junit.framework.TestCase;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)

125
server/src/test/java/com/cloud/network/vpc/NetworkACLServiceImplTest.java
View File

@ -17,42 +17,6 @@
package com.cloud.network.vpc;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.times;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.api.command.user.network.CreateNetworkACLCmd;
import org.apache.cloudstack.api.command.user.network.MoveNetworkAclItemCmd;
import org.apache.cloudstack.api.command.user.network.UpdateNetworkACLItemCmd;
import org.apache.cloudstack.api.command.user.network.UpdateNetworkACLListCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.commons.lang3.StringUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.network.Network;
@ -66,9 +30,42 @@ import com.cloud.user.AccountManager;
import com.cloud.user.User;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.exception.CloudRuntimeException;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.api.command.user.network.CreateNetworkACLCmd;
import org.apache.cloudstack.api.command.user.network.MoveNetworkAclItemCmd;
import org.apache.cloudstack.api.command.user.network.UpdateNetworkACLItemCmd;
import org.apache.cloudstack.api.command.user.network.UpdateNetworkACLListCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.commons.lang3.StringUtils;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
@RunWith(PowerMockRunner.class)
@PrepareForTest(CallContext.class)
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.times;
@RunWith(MockitoJUnitRunner.class)
public class NetworkACLServiceImplTest {
@Spy
@ -124,10 +121,12 @@ public class NetworkACLServiceImplTest {
@Mock
private CallContext callContextMock;
private MockedStatic<CallContext> callContextMocked;
@Before
public void befoteTest() {
PowerMockito.mockStatic(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
public void setup() {
callContextMocked = Mockito.mockStatic(CallContext.class);
Mockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.doReturn(Mockito.mock(User.class)).when(callContextMock).getCallingUser();
Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();
@ -140,15 +139,16 @@ public class NetworkACLServiceImplTest {
Mockito.when(moveNetworkAclItemCmdMock.getUuidRuleBeingMoved()).thenReturn(uuidAclRuleBeingMoved);
Mockito.when(aclRuleBeingMovedMock.getUuid()).thenReturn(uuidAclRuleBeingMoved);
Mockito.when(aclRuleBeingMovedMock.getAclId()).thenReturn(networkAclMockId);
Mockito.when(previousAclRuleMock.getUuid()).thenReturn(previousAclRuleUuid);
Mockito.when(nextAclRuleMock.getUuid()).thenReturn(nextAclRuleUuid);
Mockito.when(networkAclMock.getVpcId()).thenReturn(networkMockVpcMockId);
}
@After
public void tearDown() throws Exception {
callContextMocked.close();
}
@Test
public void createNetworkACLItemTestAclNumberNull() {
createNetworkACLItemTestForNumberAndExecuteTest(null);
@ -168,7 +168,6 @@ public class NetworkACLServiceImplTest {
Mockito.doNothing().when(networkAclServiceImpl).validateAclRuleNumber(createNetworkAclCmdMock, networkAclMock);
Mockito.doNothing().when(networkAclServiceImpl).validateNetworkAcl(networkAclMock);
Mockito.doReturn(Action.Allow).when(networkAclServiceImpl).validateAndCreateNetworkAclRuleAction(anyString());
Mockito.when(networkAclItemDaoMock.getMaxNumberByACL(networkAclMockId)).thenReturn(5);
Mockito.doNothing().when(networkAclServiceImpl).validateNetworkACLItem(Mockito.any(NetworkACLItemVO.class));
@ -248,15 +247,13 @@ public class NetworkACLServiceImplTest {
long networkId = 1L;
Mockito.when(createNetworkAclCmdMock.getNetworkId()).thenReturn(networkId);
Network networkMock = Mockito.mock(Network.class);
;
Mockito.when(networkMock.getVpcId()).thenReturn(12L);
Long expectedAclListId = 15L;
Mockito.when(networkMock.getNetworkACLId()).thenReturn(expectedAclListId);
Mockito.doReturn(networkMock).when(networkModelMock).getNetwork(networkId);
Mockito.doReturn(16L).when(networkAclServiceImpl).createAclListForNetworkAndReturnAclListId(createNetworkAclCmdMock, networkMock);
Long aclIdReturned = networkAclServiceImpl.createAclListIfNeeded(createNetworkAclCmdMock);
Assert.assertEquals(expectedAclListId, aclIdReturned);
@ -370,7 +367,6 @@ public class NetworkACLServiceImplTest {
@Test
public void validateAclRuleNumberTestNumberNull() {
Mockito.when(createNetworkAclCmdMock.getNumber()).thenReturn(null);
Mockito.doReturn(null).when(networkAclItemDaoMock).findByAclAndNumber(Mockito.anyLong(), Mockito.anyInt());
networkAclServiceImpl.validateAclRuleNumber(createNetworkAclCmdMock, networkAclMock);
Mockito.verify(networkAclItemDaoMock, Mockito.times(0)).findByAclAndNumber(Mockito.anyLong(), Mockito.anyInt());
@ -397,19 +393,16 @@ public class NetworkACLServiceImplTest {
public void validateNetworkAclTestAclNotDefaulWithoutVpc() {
Mockito.when(networkAclMock.getId()).thenReturn(3L);
Mockito.doReturn(null).when(entityManagerMock).findById(Vpc.class, networkMockVpcMockId);
;
networkAclServiceImpl.validateNetworkAcl(networkAclMock);
}
@Test
@PrepareForTest(CallContext.class)
public void validateNetworkAclTestAclNotDefaulWithVpc() {
CallContext callContextMock = Mockito.mock(CallContext.class);
Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();
PowerMockito.mockStatic(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.when(networkAclMock.getId()).thenReturn(3L);
Mockito.when(networkAclMock.getVpcId()).thenReturn(networkMockVpcMockId);
@ -422,8 +415,7 @@ public class NetworkACLServiceImplTest {
Mockito.verify(entityManagerMock).findById(Vpc.class, networkMockVpcMockId);
Mockito.verify(accountManagerMock).checkAccess(Mockito.any(Account.class), Mockito.isNull(AccessType.class), Mockito.eq(true), Mockito.any(Vpc.class));
PowerMockito.verifyStatic(CallContext.class);
CallContext.current();
callContextMocked.verify(() -> CallContext.current());
}
@ -554,7 +546,6 @@ public class NetworkACLServiceImplTest {
@Test
public void validateProtocolTestProtocolIsNullOrBlank() {
Mockito.doNothing().when(networkAclServiceImpl).validateIcmpTypeAndCode(networkAclItemVoMock);
Mockito.when(networkAclItemVoMock.getProtocol()).thenReturn(null);
networkAclServiceImpl.validateProtocol(networkAclItemVoMock);
@ -808,7 +799,6 @@ public class NetworkACLServiceImplTest {
Mockito.when(updateNetworkACLItemCmdMock.getReason()).thenReturn(null);
Mockito.when(updateNetworkACLItemCmdMock.isDisplay()).thenReturn(false);
Mockito.when(networkAclItemVoMock.isDisplay()).thenReturn(false);
networkAclServiceImpl.transferDataToNetworkAclRulePojo(updateNetworkACLItemCmdMock, networkAclItemVoMock, networkAclMock);
@ -846,7 +836,6 @@ public class NetworkACLServiceImplTest {
Mockito.when(updateNetworkACLItemCmdMock.getReason()).thenReturn("reason");
Mockito.when(updateNetworkACLItemCmdMock.isDisplay()).thenReturn(true);
Mockito.when(networkAclItemVoMock.isDisplay()).thenReturn(false);
networkAclServiceImpl.transferDataToNetworkAclRulePojo(updateNetworkACLItemCmdMock, networkAclItemVoMock, networkAclMock);
@ -866,7 +855,6 @@ public class NetworkACLServiceImplTest {
}
@Test
@PrepareForTest(CallContext.class)
public void updateNetworkACLTestParametersNotNull() {
String name = "name";
String description = "desc";
@ -1006,7 +994,6 @@ public class NetworkACLServiceImplTest {
Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));
Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class),
@ -1070,7 +1057,6 @@ public class NetworkACLServiceImplTest {
}
@Test
@PrepareForTest(CallContext.class)
public void updateNetworkACLTestParametersWithNullValues() {
Mockito.when(updateNetworkACLListCmdMock.getName()).thenReturn(null);
Mockito.when(updateNetworkACLListCmdMock.getDescription()).thenReturn(null);
@ -1106,8 +1092,7 @@ public class NetworkACLServiceImplTest {
CallContext callContextMock = Mockito.mock(CallContext.class);
Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();
PowerMockito.mockStatic(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.when(CallContext.current()).thenReturn(callContextMock);
Mockito.doNothing().when(accountManagerMock).checkAccess(Mockito.any(Account.class), Mockito.isNull(AccessType.class), Mockito.eq(true), Mockito.any(Vpc.class));
@ -1204,7 +1189,6 @@ public class NetworkACLServiceImplTest {
public void moveRuleBetweenAclRulesTestThereIsSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {
Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);
Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);
Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);
Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);
ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();
@ -1222,9 +1206,6 @@ public class NetworkACLServiceImplTest {
allAclRules.add(networkACLItemVO14);
allAclRules.add(aclRuleBeingMovedMock);
Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(),
Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());
@ -1252,9 +1233,6 @@ public class NetworkACLServiceImplTest {
Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);
Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(),
Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());
networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);
Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);
@ -1265,9 +1243,6 @@ public class NetworkACLServiceImplTest {
@Test
public void updateAclRuleToNewPositionAndExecuteShiftIfNecessaryTest() {
Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);
Mockito.when(previousAclRuleMock.getId()).thenReturn(50l);
Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);
Mockito.when(nextAclRuleMock.getId()).thenReturn(50l);
@ -1293,8 +1268,6 @@ public class NetworkACLServiceImplTest {
allAclRules.add(networkACLItemVO14);
allAclRules.add(aclRuleBeingMovedMock);
Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());
Map<Long, NetworkACLItemVO> updatedItems = new HashMap<>();
Mockito.doAnswer((Answer<Void>) invocation -> {
Long id = (Long)invocation.getArguments()[0];

155
server/src/test/java/com/cloud/network/vpc/VpcManagerImplTest.java
View File

@ -18,55 +18,16 @@
*/
package com.cloud.network.vpc;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.powermock.api.mockito.PowerMockito.when;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import com.cloud.alert.AlertManager;
import com.cloud.network.NetworkService;
import com.cloud.network.dao.FirewallRulesDao;
import org.apache.cloudstack.acl.SecurityChecker;
import org.apache.cloudstack.alert.AlertService;
import org.apache.cloudstack.api.command.user.vpc.UpdateVPCCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.junit.After;
import org.junit.Assert;
import org.apache.cloudstack.api.command.admin.vpc.CreateVPCOfferingCmd;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.routing.UpdateNetworkCommand;
import com.cloud.agent.api.to.IpAddressTO;
import com.cloud.agent.manager.Commands;
import com.cloud.dc.VlanVO;
import com.cloud.dc.dao.VlanDao;
import com.cloud.alert.AlertManager;
import com.cloud.configuration.Resource;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.VlanVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.dc.dao.VlanDao;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceAllocationException;
@ -76,16 +37,18 @@ import com.cloud.network.Network.Capability;
import com.cloud.network.Network.Provider;
import com.cloud.network.Network.Service;
import com.cloud.network.NetworkModel;
import com.cloud.network.NetworkService;
import com.cloud.network.PhysicalNetwork;
import com.cloud.network.dao.FirewallRulesDao;
import com.cloud.network.dao.IPAddressDao;
import com.cloud.network.dao.IPAddressVO;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.NetworkVO;
import com.cloud.network.element.NetworkElement;
import com.cloud.network.router.CommandSetupHelper;
import com.cloud.network.router.NetworkHelper;
import com.cloud.network.router.VirtualRouter;
import com.cloud.network.vpc.dao.VpcDao;
import com.cloud.network.vpc.dao.VpcOfferingDao;
import com.cloud.network.vpc.dao.VpcOfferingServiceMapDao;
import com.cloud.offering.NetworkOffering;
import com.cloud.offerings.NetworkOfferingServiceMapVO;
@ -93,19 +56,53 @@ import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.Pair;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.net.Ip;
import com.cloud.utils.net.NetUtils;
import com.cloud.vm.DomainRouterVO;
import com.cloud.vm.NicVO;
import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.NicDao;
import com.cloud.network.vpc.dao.VpcOfferingDao;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.UserVO;
import com.cloud.utils.net.NetUtils;
import org.apache.cloudstack.acl.SecurityChecker;
import org.apache.cloudstack.api.command.admin.vpc.CreateVPCOfferingCmd;
import org.apache.cloudstack.api.command.user.vpc.UpdateVPCCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@RunWith(MockitoJUnitRunner.class)
public class VpcManagerImplTest {
@Mock
@ -172,6 +169,8 @@ public class VpcManagerImplTest {
final String vpcName = "Test-VPC";
final String vpcDomain = "domain";
private AutoCloseable closeable;
private void registerCallContext() {
account = new AccountVO("testaccount", 1L, "networkdomain", Account.Type.NORMAL, "uuid");
account.setId(ACCOUNT_ID);
@ -181,9 +180,8 @@ public class VpcManagerImplTest {
}
@Before
public void setup()
{
MockitoAnnotations.initMocks(this);
public void setup() throws NoSuchFieldException, IllegalAccessException {
closeable = MockitoAnnotations.openMocks(this);
manager = new VpcManagerImpl();
manager._vpcOffSvcMapDao = vpcOfferingServiceMapDao;
manager.vpcDao = vpcDao;
@ -207,23 +205,33 @@ public class VpcManagerImplTest {
manager._firewallDao = firewallDao;
CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class));
registerCallContext();
overrideDefaultConfigValue(NetworkService.AllowUsersToSpecifyVRMtu, "_defaultValue", "false");
}
@After
public void tearDown() {
public void tearDown() throws Exception {
CallContext.unregister();
closeable.close();
}
private void overrideDefaultConfigValue(final ConfigKey configKey, final String name,
final Object o) throws IllegalAccessException, NoSuchFieldException {
Field f = ConfigKey.class.getDeclaredField(name);
f.setAccessible(true);
f.set(configKey, o);
}
@Test
public void getVpcOffSvcProvidersMapForEmptyServiceTest() {
long vpcOffId = 1L;
List<VpcOfferingServiceMapVO> list = new ArrayList<VpcOfferingServiceMapVO>();
list.add(mock(VpcOfferingServiceMapVO.class));
when(manager._vpcOffSvcMapDao.listByVpcOffId(vpcOffId)).thenReturn(list);
Mockito.when(manager._vpcOffSvcMapDao.listByVpcOffId(vpcOffId)).thenReturn(list);
Map<Service, Set<Provider>> map = manager.getVpcOffSvcProvidersMap(vpcOffId);
assertNotNull(map);
assertEquals(map.size(),1);
assertEquals(map.size(), 1);
}
protected Map<String, String> createFakeCapabilityInputMap() {
@ -249,7 +257,7 @@ public class VpcManagerImplTest {
// Execute
boolean result = Whitebox.invokeMethod(this.manager, "isVpcOfferingForRegionLevelVpc",
boolean result = ReflectionTestUtils.invokeMethod(this.manager, "isVpcOfferingForRegionLevelVpc",
serviceCapabilitystList); //, Network.Capability.RedundantRouter.getName(), Service.SourceNat);
// Assert
@ -265,7 +273,7 @@ public class VpcManagerImplTest {
serviceCapabilitystList.put("", createFakeCapabilityInputMap());
// Execute
boolean result = Whitebox.invokeMethod(this.manager, "isVpcOfferingForRegionLevelVpc",
boolean result = ReflectionTestUtils.invokeMethod(this.manager, "isVpcOfferingForRegionLevelVpc",
serviceCapabilitystList);
// Assert
@ -305,10 +313,10 @@ public class VpcManagerImplTest {
final boolean distributedRouter = true;
final NetworkElement nwElement1 = mock(NetworkElement.class);
this.manager._ntwkModel = mock(NetworkModel.class);
when(this.manager._ntwkModel.getElementImplementingProvider(Provider.VPCVirtualRouter.getName()))
Mockito.when(this.manager._ntwkModel.getElementImplementingProvider(Provider.VPCVirtualRouter.getName()))
.thenReturn(nwElement1);
final Map<Service, Map<Network.Capability, String>> capabilitiesService1 = new HashMap<>();
when(nwElement1.getCapabilities()).thenReturn(capabilitiesService1);
Mockito.when(nwElement1.getCapabilities()).thenReturn(capabilitiesService1);
capabilities.put(Capability.RegionLevelVpc, "");
capabilities.put(Capability.DistributedRouter, "");
capabilitiesService1.put(service, capabilities);
@ -329,9 +337,8 @@ public class VpcManagerImplTest {
services.add(Service.SourceNat);
List<NetworkOfferingServiceMapVO> serviceMap = new ArrayList<>();
Mockito.when(vpcDao.findById(anyLong())).thenReturn(vpcMockVO);
Mockito.when(manager.getActiveVpc(anyLong())).thenReturn(vpcMock);
lenient().doNothing().when(accountManager).checkAccess(any(Account.class), nullable(SecurityChecker.AccessType.class), anyBoolean(), any(Vpc.class));
doNothing().when(accountManager).checkAccess(any(Account.class), nullable(SecurityChecker.AccessType.class), anyBoolean(), any(Vpc.class));
Mockito.when(vpcMock.isRegionLevelVpc()).thenReturn(true);
Mockito.when(entityMgr.findById(NetworkOffering.class, 1L)).thenReturn(offering);
Mockito.when(vpcMock.getId()).thenReturn(VPC_ID);
@ -380,7 +387,6 @@ public class VpcManagerImplTest {
IpAddressTO[] ipsToSend = ips.toArray(new IpAddressTO[0]);
Mockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock);
Mockito.when(vpcDao.findById(vpcId)).thenReturn(vpcVO);
Mockito.when(vpcDao.createForUpdate(anyLong())).thenReturn(vpcVO);
Mockito.when(ipAddressDao.listByAssociatedVpc(anyLong(), nullable(Boolean.class))).thenReturn(ipAddresses);
@ -389,19 +395,15 @@ public class VpcManagerImplTest {
Mockito.when(vlanVO.getVlanNetmask()).thenReturn("netmask");
Mockito.when(vlanDao.findById(anyLong())).thenReturn(vlanVO);
Mockito.doAnswer((org.mockito.stubbing.Answer<Void>) invocation -> {
Commands commands = (Commands)invocation.getArguments()[2];
Commands commands = (Commands) invocation.getArguments()[2];
commands.addCommand("updateNetwork", new UpdateNetworkCommand(ipsToSend));
return null;
}).when(commandSetupHelper).setupUpdateNetworkCommands(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doAnswer((org.mockito.stubbing.Answer<Boolean>) invocation -> {
Commands commands = (Commands)invocation.getArguments()[1];
Commands commands = (Commands) invocation.getArguments()[1];
commands.setAnswers(new Answer[]{answer});
return true;
}).when(networkHelper).sendCommandsToRouter(Mockito.any(), Mockito.any());
Mockito.when(nicDao.findByIpAddressAndVmType(anyString(), any())).thenReturn(Mockito.mock(NicVO.class));
Mockito.when(nicDao.update(anyLong(), any())).thenReturn(true);
Mockito.when(networkDao.listByVpc(vpcId)).thenReturn(List.of(Mockito.mock(NetworkVO.class)));
Mockito.when(networkDao.update(anyLong(), any())).thenReturn(true);
Mockito.when(vpcDao.update(vpcId, vpcVO)).thenReturn(true);
UpdateVPCCmd cmd = Mockito.mock(UpdateVPCCmd.class);
@ -426,7 +428,6 @@ public class VpcManagerImplTest {
Mockito.when(ipAddressDao.findByIp(sourceNatIp)).thenReturn(requestedIp);
Mockito.when(requestedIp.getVpcId()).thenReturn(1l);
Mockito.when(requestedIp.getVpcId()).thenReturn(1l);
Mockito.when(firewallDao.countRulesByIpId(1l)).thenReturn(0l);
Assert.assertNull(manager.validateSourceNatip(vpcVO, null));
Assert.assertEquals(requestedIp, manager.validateSourceNatip(vpcVO, sourceNatIp));
}
@ -435,13 +436,9 @@ public class VpcManagerImplTest {
public void testUpdatePublicMtuToGreaterThanThreshold() {
Integer publicMtu = 2500;
Integer expectedMtu = 1500;
Long vpcId = 1L;
VpcVO vpcVO = new VpcVO();
Mockito.when(vpcDao.findById(vpcId)).thenReturn(vpcVO);
Mockito.when(vpcDao.createForUpdate(anyLong())).thenReturn(vpcVO);
lenient().doNothing().when(alertManager).sendAlert(any(AlertService.AlertType.class), anyLong(), anyLong(), anyString(), anyString());
Integer mtu = manager.validateMtu(vpcVO, publicMtu);
Assert.assertEquals(expectedMtu, mtu);
}
@ -450,7 +447,7 @@ public class VpcManagerImplTest {
public void testDisabledConfigCreateIpv6VpcOffering() {
CreateVPCOfferingCmd cmd = Mockito.mock(CreateVPCOfferingCmd.class);
Mockito.when(cmd.getInternetProtocol()).thenReturn(NetUtils.InternetProtocol.DualStack.toString());
Mockito.doNothing().when(networkServiceMock).validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouter(Mockito.any());
doNothing().when(networkServiceMock).validateIfServiceOfferingIsActiveAndSystemVmTypeIsDomainRouter(Mockito.any());
manager.createVpcOffering(cmd);
}
@ -461,23 +458,17 @@ public class VpcManagerImplTest {
Mockito.when(vpcOfferingVO.getState()).thenReturn(VpcOffering.State.Enabled);
Mockito.when(vpcOfferingDao.findById(vpcOfferingId)).thenReturn(vpcOfferingVO);
DataCenterVO dataCenterVO = Mockito.mock(DataCenterVO.class);
Mockito.when(dataCenterVO.getId()).thenReturn(zoneId);
Mockito.when(dataCenterDao.findById(zoneId)).thenReturn(dataCenterVO);
Mockito.doNothing().when(accountManager).checkAccess(account, vpcOfferingVO, dataCenterVO);
doNothing().when(accountManager).checkAccess(account, vpcOfferingVO, dataCenterVO);
Mockito.when(vpcOfferingServiceMapDao.areServicesSupportedByVpcOffering(vpcOfferingId, new Service[]{Service.Dns})).thenReturn(supportDnsService);
Mockito.when(vpcOfferingDao.isIpv6Supported(vpcOfferingId)).thenReturn(isIpv6);
try {
Mockito.doNothing().when(resourceLimitService).checkResourceLimit(account, Resource.ResourceType.vpc);
} catch (ResourceAllocationException e) {
Assert.fail(String.format("checkResourceLimit failure with exception: %s", e.getMessage()));
}
}
@Test(expected = InvalidParameterValueException.class)
public void testCreateVpcDnsOfferingServiceFailure() {
mockVpcDnsResources(false, false);
try {
Mockito.doNothing().when(resourceLimitService).checkResourceLimit(account, Resource.ResourceType.vpc);
doNothing().when(resourceLimitService).checkResourceLimit(account, Resource.ResourceType.vpc);
manager.createVpc(zoneId, vpcOfferingId, vpcOwnerId, vpcName, vpcName, ip4Cidr, vpcDomain,
ip4Dns[0], null, null, null, true, 1500);
} catch (ResourceAllocationException e) {
@ -489,7 +480,7 @@ public class VpcManagerImplTest {
public void testCreateVpcDnsIpv6OfferingFailure() {
mockVpcDnsResources(true, false);
try {
Mockito.doNothing().when(resourceLimitService).checkResourceLimit(account, Resource.ResourceType.vpc);
doNothing().when(resourceLimitService).checkResourceLimit(account, Resource.ResourceType.vpc);
manager.createVpc(zoneId, vpcOfferingId, vpcOwnerId, vpcName, vpcName, ip4Cidr, vpcDomain,
ip4Dns[0], ip4Dns[1], ip6Dns[0], null, true, 1500);
} catch (ResourceAllocationException e) {

89
server/src/test/java/com/cloud/network/vpn/RemoteAccessVpnManagerImplTest.java
View File

@ -17,18 +17,18 @@ package com.cloud.network.vpn;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.net.NetUtils;
import java.lang.reflect.InvocationTargetException;
import javax.naming.ConfigurationException;
import junit.framework.TestCase;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest(NetUtils.class)
import javax.naming.ConfigurationException;
import java.lang.reflect.InvocationTargetException;
@RunWith(MockitoJUnitRunner.class)
public class RemoteAccessVpnManagerImplTest extends TestCase {
Class<InvalidParameterValueException> expectedException = InvalidParameterValueException.class;
@ -64,16 +64,16 @@ public class RemoteAccessVpnManagerImplTest extends TestCase {
String[] range = ipRange.split("-");
String expectedMessage = String.format("One or both IPs sets in the range [%s] are invalid IPs.", ipRange);
PowerMockito.mockStatic(NetUtils.class);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.FALSE);
Mockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.FALSE);
PowerMockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.TRUE);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
assertEquals(expectedMessage, assertThrows.getMessage());
assertEquals(expectedMessage, assertThrows.getMessage());
}
}
@Test
@ -82,16 +82,17 @@ public class RemoteAccessVpnManagerImplTest extends TestCase {
String[] range = ipRange.split("-");
String expectedMessage = String.format("One or both IPs sets in the range [%s] are invalid IPs.", ipRange);
PowerMockito.mockStatic(NetUtils.class);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
PowerMockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.FALSE);
Mockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.TRUE);
Mockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.FALSE);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
assertEquals(expectedMessage, assertThrows.getMessage());
assertEquals(expectedMessage, assertThrows.getMessage());
}
}
@Test
@ -100,16 +101,17 @@ public class RemoteAccessVpnManagerImplTest extends TestCase {
String[] range = ipRange.split("-");
String expectedMessage = String.format("One or both IPs sets in the range [%s] are invalid IPs.", ipRange);
PowerMockito.mockStatic(NetUtils.class);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
PowerMockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.FALSE);
PowerMockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.FALSE);
Mockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.FALSE);
Mockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.FALSE);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
assertEquals(expectedMessage, assertThrows.getMessage());
assertEquals(expectedMessage, assertThrows.getMessage());
}
}
@Test
@ -118,17 +120,18 @@ public class RemoteAccessVpnManagerImplTest extends TestCase {
String[] range = ipRange.split("-");
String expectedMessage = String.format("Range of IPs [%s] is invalid.", ipRange);
PowerMockito.mockStatic(NetUtils.class);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
PowerMockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.validIpRange(range[0], range[1])).thenReturn(Boolean.FALSE);
Mockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.TRUE);
Mockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.TRUE);
Mockito.when(NetUtils.validIpRange(range[0], range[1])).thenReturn(Boolean.FALSE);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedMessage, expectedException, () -> {
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
});
assertEquals(expectedMessage, assertThrows.getMessage());
assertEquals(expectedMessage, assertThrows.getMessage());
}
}
@Test
@ -136,13 +139,13 @@ public class RemoteAccessVpnManagerImplTest extends TestCase {
String ipRange = "192.168.0.1-192.168.0.255";
String[] range = ipRange.split("-");
PowerMockito.mockStatic(NetUtils.class);
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.TRUE);
Mockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.TRUE);
Mockito.when(NetUtils.validIpRange(range[0], range[1])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.isValidIp4(range[0])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.isValidIp4(range[1])).thenReturn(Boolean.TRUE);
PowerMockito.when(NetUtils.validIpRange(range[0], range[1])).thenReturn(Boolean.TRUE);
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
new RemoteAccessVpnManagerImpl().validateIpRange(ipRange, expectedException);
}
}
private <T extends Throwable> void handleExceptionOnValidateIpRangeErrorMustThrowCloudRuntimeException(Class<T> exceptionToCatch){

9
server/src/test/java/com/cloud/projects/MockProjectManagerImpl.java
View File

@ -16,11 +16,6 @@
// under the License.
package com.cloud.projects;
import java.util.List;
import java.util.Map;
import javax.naming.ConfigurationException;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.exception.ResourceUnavailableException;
@ -28,6 +23,10 @@ import com.cloud.projects.ProjectAccount.Role;
import com.cloud.user.Account;
import com.cloud.utils.component.ManagerBase;
import javax.naming.ConfigurationException;
import java.util.List;
import java.util.Map;
public class MockProjectManagerImpl extends ManagerBase implements ProjectManager {
@Override

7
server/src/test/java/com/cloud/projects/ProjectManagerImplTest.java
View File

@ -16,9 +16,7 @@
// under the License.
package com.cloud.projects;
import java.util.ArrayList;
import java.util.List;
import com.cloud.projects.dao.ProjectDao;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -30,7 +28,8 @@ import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import com.cloud.projects.dao.ProjectDao;
import java.util.ArrayList;
import java.util.List;
@RunWith(MockitoJUnitRunner.class)

39
server/src/test/java/com/cloud/resource/MockResourceManagerImpl.java
View File

@ -17,27 +17,6 @@
package com.cloud.resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.naming.ConfigurationException;
import org.apache.cloudstack.api.command.admin.cluster.AddClusterCmd;
import org.apache.cloudstack.api.command.admin.cluster.DeleteClusterCmd;
import org.apache.cloudstack.api.command.admin.cluster.UpdateClusterCmd;
import org.apache.cloudstack.api.command.admin.host.AddHostCmd;
import org.apache.cloudstack.api.command.admin.host.AddSecondaryStorageCmd;
import org.apache.cloudstack.api.command.admin.host.CancelMaintenanceCmd;
import org.apache.cloudstack.api.command.admin.host.PrepareForMaintenanceCmd;
import org.apache.cloudstack.api.command.admin.host.ReconnectHostCmd;
import org.apache.cloudstack.api.command.admin.host.UpdateHostCmd;
import org.apache.cloudstack.api.command.admin.host.UpdateHostPasswordCmd;
import org.apache.cloudstack.api.command.admin.host.CancelHostAsDegradedCmd;
import org.apache.cloudstack.api.command.admin.host.DeclareHostAsDegradedCmd;
import org.apache.cloudstack.framework.config.ConfigKey;
import com.cloud.agent.api.StartupCommand;
import com.cloud.agent.api.StartupRoutingCommand;
import com.cloud.agent.api.VgpuTypesInfo;
@ -61,6 +40,24 @@ import com.cloud.org.Cluster;
import com.cloud.resource.ResourceState.Event;
import com.cloud.utils.component.ManagerBase;
import com.cloud.utils.fsm.NoTransitionException;
import org.apache.cloudstack.api.command.admin.cluster.AddClusterCmd;
import org.apache.cloudstack.api.command.admin.cluster.DeleteClusterCmd;
import org.apache.cloudstack.api.command.admin.cluster.UpdateClusterCmd;
import org.apache.cloudstack.api.command.admin.host.AddHostCmd;
import org.apache.cloudstack.api.command.admin.host.AddSecondaryStorageCmd;
import org.apache.cloudstack.api.command.admin.host.CancelHostAsDegradedCmd;
import org.apache.cloudstack.api.command.admin.host.CancelMaintenanceCmd;
import org.apache.cloudstack.api.command.admin.host.DeclareHostAsDegradedCmd;
import org.apache.cloudstack.api.command.admin.host.PrepareForMaintenanceCmd;
import org.apache.cloudstack.api.command.admin.host.ReconnectHostCmd;
import org.apache.cloudstack.api.command.admin.host.UpdateHostCmd;
import org.apache.cloudstack.api.command.admin.host.UpdateHostPasswordCmd;
import org.apache.cloudstack.framework.config.ConfigKey;
import javax.naming.ConfigurationException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MockResourceManagerImpl extends ManagerBase implements ResourceManager {

161
server/src/test/java/com/cloud/resource/ResourceManagerImplTest.java
View File

@ -17,47 +17,6 @@
package com.cloud.resource;
import static com.cloud.resource.ResourceState.Event.ErrorsCorrected;
import static com.cloud.resource.ResourceState.Event.InternalEnterMaintenance;
import static com.cloud.resource.ResourceState.Event.UnableToMaintain;
import static com.cloud.resource.ResourceState.Event.UnableToMigrate;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import com.cloud.storage.Volume;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.VolumeDao;
import org.apache.cloudstack.api.command.admin.host.CancelHostAsDegradedCmd;
import org.apache.cloudstack.api.command.admin.host.DeclareHostAsDegradedCmd;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.BDDMockito;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.GetVncPortAnswer;
import com.cloud.agent.api.GetVncPortCommand;
@ -71,6 +30,9 @@ import com.cloud.host.Status;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.storage.StorageManager;
import com.cloud.storage.Volume;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.utils.Ternary;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.fsm.NoTransitionException;
@ -81,9 +43,45 @@ import com.cloud.vm.VirtualMachine;
import com.cloud.vm.dao.UserVmDetailsDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.trilead.ssh2.Connection;
import org.apache.cloudstack.api.command.admin.host.CancelHostAsDegradedCmd;
import org.apache.cloudstack.api.command.admin.host.DeclareHostAsDegradedCmd;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.BDDMockito;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedConstruction;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ActionEventUtils.class, ResourceManagerImpl.class, SSHCmdHelper.class})
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import static com.cloud.resource.ResourceState.Event.ErrorsCorrected;
import static com.cloud.resource.ResourceState.Event.InternalEnterMaintenance;
import static com.cloud.resource.ResourceState.Event.UnableToMaintain;
import static com.cloud.resource.ResourceState.Event.UnableToMigrate;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ResourceManagerImplTest {
@Mock
@ -120,11 +118,6 @@ public class ResourceManagerImplTest {
private GetVncPortAnswer getVncPortAnswerVm1;
@Mock
private GetVncPortAnswer getVncPortAnswerVm2;
@Mock
private GetVncPortCommand getVncPortCommandVm1;
@Mock
private GetVncPortCommand getVncPortCommandVm2;
@Mock
private VolumeVO rootDisk1;
@Mock
@ -154,15 +147,18 @@ public class ResourceManagerImplTest {
private static long poolId = 1L;
private List<VolumeVO> rootDisks;
private List<VolumeVO> dataDisks;
private MockedStatic<SSHCmdHelper> sshHelperMocked;
private MockedStatic<ActionEventUtils> actionEventUtilsMocked;
private MockedConstruction<GetVncPortCommand> getVncPortCommandMockedConstruction;
private AutoCloseable closeable;
@Before
public void setup() throws Exception {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
when(host.getType()).thenReturn(Host.Type.Routing);
when(host.getId()).thenReturn(hostId);
when(host.getResourceState()).thenReturn(ResourceState.Enabled);
when(host.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);
when(host.getClusterId()).thenReturn(1L);
when(hostDao.findById(hostId)).thenReturn(host);
when(host.getDetail("username")).thenReturn(hostUsername);
when(host.getDetail("password")).thenReturn(hostPassword);
@ -176,19 +172,22 @@ public class ResourceManagerImplTest {
when(vmInstanceDao.listByHostId(hostId)).thenReturn(new ArrayList<>());
when(vmInstanceDao.listVmsMigratingFromHost(hostId)).thenReturn(new ArrayList<>());
when(vmInstanceDao.listNonMigratingVmsByHostEqualsLastHost(hostId)).thenReturn(new ArrayList<>());
PowerMockito.mockStatic(ActionEventUtils.class);
actionEventUtilsMocked = Mockito.mockStatic(ActionEventUtils.class);
BDDMockito.given(ActionEventUtils.onCompletedActionEvent(anyLong(), anyLong(), anyString(), anyString(), anyString(), anyLong(), anyString(), anyLong()))
.willReturn(1L);
when(getVncPortAnswerVm1.getAddress()).thenReturn(vm1VncAddress);
when(getVncPortAnswerVm1.getPort()).thenReturn(vm1VncPort);
when(getVncPortAnswerVm2.getAddress()).thenReturn(vm2VncAddress);
when(getVncPortAnswerVm2.getPort()).thenReturn(vm2VncPort);
PowerMockito.whenNew(GetVncPortCommand.class).withArguments(vm1Id, vm1InstanceName).thenReturn(getVncPortCommandVm1);
PowerMockito.whenNew(GetVncPortCommand.class).withArguments(vm2Id, vm2InstanceName).thenReturn(getVncPortCommandVm2);
when(agentManager.easySend(eq(hostId), eq(getVncPortCommandVm1))).thenReturn(getVncPortAnswerVm1);
when(agentManager.easySend(eq(hostId), eq(getVncPortCommandVm2))).thenReturn(getVncPortAnswerVm2);
getVncPortCommandMockedConstruction = Mockito.mockConstruction(GetVncPortCommand.class, (mock,context) -> {
if (context.arguments().get(0).equals(vm1Id) && context.arguments().get(1) == vm1InstanceName) {
when(agentManager.easySend(eq(hostId), eq(mock))).thenReturn(getVncPortAnswerVm1);
} else if (context.arguments().get(0).equals(vm2Id) && context.arguments().get(1) == vm2InstanceName) {
when(agentManager.easySend(eq(hostId), eq(mock))).thenReturn(getVncPortAnswerVm2);
}
});
PowerMockito.mockStatic(SSHCmdHelper.class);
sshHelperMocked = Mockito.mockStatic(SSHCmdHelper.class);
BDDMockito.given(SSHCmdHelper.acquireAuthorizedConnection(eq(hostPrivateIp), eq(22),
eq(hostUsername), eq(hostPassword), eq(hostPrivateKey))).willReturn(sshConnection);
BDDMockito.given(SSHCmdHelper.sshExecuteCmdOneShot(eq(sshConnection),
@ -203,15 +202,23 @@ public class ResourceManagerImplTest {
when(volumeDao.findByPoolId(poolId, Volume.Type.DATADISK)).thenReturn(dataDisks);
}
@After
public void tearDown() throws Exception {
sshHelperMocked.close();
actionEventUtilsMocked.close();
getVncPortCommandMockedConstruction.close();
closeable.close();
}
@Test
public void testCheckAndMaintainEnterMaintenanceModeNoVms() throws NoTransitionException {
// Test entering into maintenance with no VMs running on host.
boolean enterMaintenanceMode = resourceManager.checkAndMaintain(hostId);
verify(resourceManager).attemptMaintain(host);
verify(resourceManager).setHostIntoMaintenance(host);
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(anyObject());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(any());
verify(resourceManager).resourceStateTransitTo(eq(host), eq(InternalEnterMaintenance), anyLong());
Assert.assertTrue(enterMaintenanceMode);
@ -306,11 +313,11 @@ public class ResourceManagerImplTest {
verify(agentManager).pullAgentOutMaintenance(hostId);
verify(resourceManager).setKVMVncAccess(hostId, vms);
verify(agentManager, times(vms.size())).easySend(eq(hostId), any(GetVncPortCommand.class));
verify(agentManager).pullAgentToMaintenance(hostId);
verify(userVmDetailsDao).addDetail(eq(vm1Id), eq("kvm.vnc.address"), eq(vm1VncAddress), anyBoolean());
verify(userVmDetailsDao).addDetail(eq(vm1Id), eq("kvm.vnc.port"), eq(String.valueOf(vm1VncPort)), anyBoolean());
verify(userVmDetailsDao).addDetail(eq(vm2Id), eq("kvm.vnc.address"), eq(vm2VncAddress), anyBoolean());
verify(userVmDetailsDao).addDetail(eq(vm2Id), eq("kvm.vnc.port"), eq(String.valueOf(vm2VncPort)), anyBoolean());
verify(agentManager).pullAgentToMaintenance(hostId);
}
@Test(expected = CloudRuntimeException.class)
@ -374,7 +381,6 @@ public class ResourceManagerImplTest {
@Test
public void testHandleAgentSSHDisabledConnectedAgent() {
when(host.getStatus()).thenReturn(Status.Up);
when(configurationDao.getValue(ResourceManager.KvmSshToAgentEnabled.key())).thenReturn("false");
resourceManager.handleAgentIfNotConnected(host, false);
verify(resourceManager, never()).getHostCredentials(eq(host));
verify(resourceManager, never()).connectAndRestartAgentOnHost(eq(host), eq(hostUsername), eq(hostPassword), eq(hostPrivateKey));
@ -400,7 +406,6 @@ public class ResourceManagerImplTest {
private void setupPendingMigrationRetries() {
when(haManager.hasPendingMigrationsWork(vm1.getId())).thenReturn(true);
when(haManager.hasPendingMigrationsWork(vm2.getId())).thenReturn(false);
}
private void setupFailedMigrations() {
@ -418,10 +423,10 @@ public class ResourceManagerImplTest {
private void verifyErrorInMaintenanceCalls() throws NoTransitionException {
boolean enterMaintenanceMode = resourceManager.checkAndMaintain(hostId);
verify(resourceManager).attemptMaintain(host);
verify(resourceManager).setHostIntoErrorInMaintenance(eq(host), anyObject());
verify(resourceManager, never()).setHostIntoMaintenance(anyObject());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(anyObject());
verify(resourceManager).setHostIntoErrorInMaintenance(eq(host), any());
verify(resourceManager, never()).setHostIntoMaintenance(any());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(any());
verify(resourceManager).resourceStateTransitTo(eq(host), eq(UnableToMaintain), anyLong());
Assert.assertFalse(enterMaintenanceMode);
}
@ -429,10 +434,10 @@ public class ResourceManagerImplTest {
private void verifyErrorInPrepareForMaintenanceCalls() throws NoTransitionException {
boolean enterMaintenanceMode = resourceManager.checkAndMaintain(hostId);
verify(resourceManager).attemptMaintain(host);
verify(resourceManager).setHostIntoErrorInPrepareForMaintenance(eq(host), anyObject());
verify(resourceManager, never()).setHostIntoMaintenance(anyObject());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(anyObject());
verify(resourceManager).setHostIntoErrorInPrepareForMaintenance(eq(host), any());
verify(resourceManager, never()).setHostIntoMaintenance(any());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(any());
verify(resourceManager).resourceStateTransitTo(eq(host), eq(UnableToMigrate), anyLong());
Assert.assertFalse(enterMaintenanceMode);
}
@ -442,20 +447,20 @@ public class ResourceManagerImplTest {
verify(resourceManager).attemptMaintain(host);
verify(resourceManager).setHostIntoPrepareForMaintenanceAfterErrorsFixed(eq(host));
verify(resourceManager).resourceStateTransitTo(eq(host), eq(ErrorsCorrected), anyLong());
verify(resourceManager, never()).setHostIntoMaintenance(anyObject());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoMaintenance(any());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(any(), any());
Assert.assertFalse(enterMaintenanceMode);
}
private void verifyNoChangeInMaintenance() throws NoTransitionException {
boolean enterMaintenanceMode = resourceManager.checkAndMaintain(hostId);
verify(resourceManager).attemptMaintain(host);
verify(resourceManager, never()).setHostIntoMaintenance(anyObject());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(anyObject(), anyObject());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(anyObject());
verify(resourceManager, never()).resourceStateTransitTo(anyObject(), any(), anyLong());
verify(resourceManager, never()).setHostIntoMaintenance(any());
verify(resourceManager, never()).setHostIntoErrorInPrepareForMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoErrorInMaintenance(any(), any());
verify(resourceManager, never()).setHostIntoPrepareForMaintenanceAfterErrorsFixed(any());
verify(resourceManager, never()).resourceStateTransitTo(any(), any(), anyLong());
Assert.assertFalse(enterMaintenanceMode);
}

35
server/src/test/java/com/cloud/resourceicon/ResourceIconManagerImplTest.java
View File

@ -16,24 +16,6 @@
// under the License.
package com.cloud.resourceicon;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.context.CallContext;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.network.dao.NetworkVO;
import com.cloud.resource.icon.ResourceIconVO;
import com.cloud.resource.icon.dao.ResourceIconDao;
@ -49,6 +31,23 @@ import com.cloud.user.dao.UserDao;
import com.cloud.utils.db.EntityManager;
import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.context.CallContext;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ResourceIconManagerImplTest {

25
server/src/test/java/com/cloud/resourcelimit/CheckedReservationTest.java
View File

@ -26,20 +26,20 @@ import com.cloud.utils.db.GlobalLock;
import com.cloud.utils.exception.CloudRuntimeException;
import org.apache.cloudstack.reservation.ReservationVO;
import org.apache.cloudstack.reservation.dao.ReservationDao;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
@PrepareForTest(CheckedReservation.class)
@RunWith(MockitoJUnitRunner.class)
public class CheckedReservationTest {
@Mock
@ -55,18 +55,21 @@ public class CheckedReservationTest {
@Mock
GlobalLock quotaLimitLock;
private AutoCloseable closeable;
@Before
public void setup() {
initMocks(this);
when(reservation.getId()).thenReturn(1l);
closeable = MockitoAnnotations.openMocks(this);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void getId() {
when(reservationDao.persist(any())).thenReturn(reservation);
when(account.getAccountId()).thenReturn(1l);
when(account.getDomainId()).thenReturn(4l);
when(quotaLimitLock.lock(anyInt())).thenReturn(true);
boolean fail = false;
try (CheckedReservation cr = new CheckedReservation(account, Resource.ResourceType.user_vm,1l, reservationDao, resourceLimitService); ) {
long id = cr.getId();
@ -85,8 +88,6 @@ public class CheckedReservationTest {
@Test
public void getNoAmount() {
when(reservationDao.persist(any())).thenReturn(reservation);
when(account.getAccountId()).thenReturn(1l);
boolean fail = false;
try (CheckedReservation cr = new CheckedReservation(account, Resource.ResourceType.cpu,-11l, reservationDao, resourceLimitService); ) {
Long amount = cr.getReservedAmount();

6
server/src/test/java/com/cloud/resourcelimit/ResourceLimitManagerImplTest.java
View File

@ -16,16 +16,14 @@
// under the License.
package com.cloud.resourcelimit;
import com.cloud.configuration.ResourceLimit;
import com.cloud.vpc.MockResourceLimitManagerImpl;
import junit.framework.TestCase;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.cloud.configuration.ResourceLimit;
import com.cloud.vpc.MockResourceLimitManagerImpl;
public class ResourceLimitManagerImplTest extends TestCase {
private static final Logger s_logger = Logger.getLogger(ResourceLimitManagerImplTest.class);

23
server/src/test/java/com/cloud/server/ConfigurationServerImplTest.java
View File

@ -16,18 +16,6 @@
// under the License.
package com.cloud.server;
import org.apache.cloudstack.framework.config.ConfigDepot;
import org.apache.cloudstack.framework.config.ConfigDepotAdmin;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.configuration.dao.ResourceCountDao;
import com.cloud.dc.dao.DataCenterDao;
@ -41,6 +29,17 @@ import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.dao.DiskOfferingDao;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.db.TransactionLegacy;
import org.apache.cloudstack.framework.config.ConfigDepot;
import org.apache.cloudstack.framework.config.ConfigDepotAdmin;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class ConfigurationServerImplTest {

462
server/src/test/java/com/cloud/server/ManagementServerImplTest.java
View File

@ -16,41 +16,6 @@
// under the License.
package com.cloud.server;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.command.user.address.ListPublicIpAddressesCmd;
import org.apache.cloudstack.api.command.user.ssh.RegisterSSHKeyPairCmd;
import org.apache.cloudstack.api.command.user.userdata.DeleteUserDataCmd;
import org.apache.cloudstack.api.command.user.userdata.ListUserDataCmd;
import org.apache.cloudstack.api.command.user.userdata.RegisterUserDataCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.userdata.UserDataManager;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.dc.Vlan.VlanType;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.host.DetailVO;
@ -80,9 +45,41 @@ import com.cloud.vm.UserVmDetailVO;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.UserVmDetailsDao;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.api.BaseCmd;
import org.apache.cloudstack.api.command.user.address.ListPublicIpAddressesCmd;
import org.apache.cloudstack.api.command.user.ssh.RegisterSSHKeyPairCmd;
import org.apache.cloudstack.api.command.user.userdata.DeleteUserDataCmd;
import org.apache.cloudstack.api.command.user.userdata.ListUserDataCmd;
import org.apache.cloudstack.api.command.user.userdata.RegisterUserDataCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.userdata.UserDataManager;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(CallContext.class)
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ManagementServerImplTest {
@Mock
@ -127,20 +124,17 @@ public class ManagementServerImplTest {
@Spy
ManagementServerImpl spy = new ManagementServerImpl();
ConfigKey mockConfig;
@Mock
UserVmDetailsDao userVmDetailsDao;
@Mock
HostDetailsDao hostDetailsDao;
private AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
public void setup() throws IllegalAccessException, NoSuchFieldException {
closeable = MockitoAnnotations.openMocks(this);
CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class));
mockConfig = Mockito.mock(ConfigKey.class);
Whitebox.setInternalState(ipAddressManagerImpl.getClass(), "SystemVmPublicIpReservationModeStrictness", mockConfig);
spy._accountMgr = _accountMgr;
spy.userDataDao = _userDataDao;
spy.templateDao = _templateDao;
@ -154,6 +148,13 @@ public class ManagementServerImplTest {
@After
public void tearDown() throws Exception {
CallContext.unregister();
closeable.close();
}
private void overrideDefaultConfigValue(final ConfigKey configKey, final String name, final Object o) throws IllegalAccessException, NoSuchFieldException {
Field f = ConfigKey.class.getDeclaredField(name);
f.setAccessible(true);
f.set(configKey, o);
}
@Test(expected = InvalidParameterValueException.class)
@ -209,7 +210,7 @@ public class ManagementServerImplTest {
@Test
public void setParametersTestWhenStateIsFreeAndSystemVmPublicIsTrue() throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
Mockito.when(mockConfig.value()).thenReturn(Boolean.TRUE);
overrideDefaultConfigValue(ipAddressManagerImpl.SystemVmPublicIpReservationModeStrictness, "_defaultValue", "true");
ListPublicIpAddressesCmd cmd = Mockito.mock(ListPublicIpAddressesCmd.class);
Mockito.when(cmd.getNetworkId()).thenReturn(10L);
@ -232,8 +233,8 @@ public class ManagementServerImplTest {
}
@Test
public void setParametersTestWhenStateIsFreeAndSystemVmPublicIsFalse() {
Mockito.when(mockConfig.value()).thenReturn(Boolean.FALSE);
public void setParametersTestWhenStateIsFreeAndSystemVmPublicIsFalse() throws NoSuchFieldException, IllegalAccessException {
overrideDefaultConfigValue(ipAddressManagerImpl.SystemVmPublicIpReservationModeStrictness, "_defaultValue", "false");
ListPublicIpAddressesCmd cmd = Mockito.mock(ListPublicIpAddressesCmd.class);
Mockito.when(cmd.getNetworkId()).thenReturn(10L);
Mockito.when(cmd.getZoneId()).thenReturn(null);
@ -255,8 +256,8 @@ public class ManagementServerImplTest {
}
@Test
public void setParametersTestWhenStateIsNullAndSystemVmPublicIsFalse() {
Mockito.when(mockConfig.value()).thenReturn(Boolean.FALSE);
public void setParametersTestWhenStateIsNullAndSystemVmPublicIsFalse() throws NoSuchFieldException, IllegalAccessException {
overrideDefaultConfigValue(ipAddressManagerImpl.SystemVmPublicIpReservationModeStrictness, "_defaultValue", "false");
ListPublicIpAddressesCmd cmd = Mockito.mock(ListPublicIpAddressesCmd.class);
Mockito.when(cmd.getNetworkId()).thenReturn(10L);
Mockito.when(cmd.getZoneId()).thenReturn(null);
@ -277,8 +278,8 @@ public class ManagementServerImplTest {
}
@Test
public void setParametersTestWhenStateIsNullAndSystemVmPublicIsTrue() {
Mockito.when(mockConfig.value()).thenReturn(Boolean.TRUE);
public void setParametersTestWhenStateIsNullAndSystemVmPublicIsTrue() throws NoSuchFieldException, IllegalAccessException {
overrideDefaultConfigValue(ipAddressManagerImpl.SystemVmPublicIpReservationModeStrictness, "_defaultValue", "true");
ListPublicIpAddressesCmd cmd = Mockito.mock(ListPublicIpAddressesCmd.class);
Mockito.when(cmd.getNetworkId()).thenReturn(10L);
Mockito.when(cmd.getZoneId()).thenReturn(null);
@ -300,263 +301,252 @@ public class ManagementServerImplTest {
@Test
public void testSuccessfulRegisterUserdata() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
String testUserData = "testUserdata";
RegisterUserDataCmd cmd = Mockito.mock(RegisterUserDataCmd.class);
when(cmd.getUserData()).thenReturn(testUserData);
when(cmd.getName()).thenReturn("testName");
when(cmd.getHttpMethod()).thenReturn(BaseCmd.HTTPMethod.GET);
String testUserData = "testUserdata";
RegisterUserDataCmd cmd = Mockito.mock(RegisterUserDataCmd.class);
when(cmd.getUserData()).thenReturn(testUserData);
when(cmd.getName()).thenReturn("testName");
when(cmd.getHttpMethod()).thenReturn(BaseCmd.HTTPMethod.GET);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
when(_userDataDao.findByUserData(account.getAccountId(), account.getDomainId(), testUserData)).thenReturn(null);
when(userDataManager.validateUserData(testUserData,BaseCmd.HTTPMethod.GET)).thenReturn(testUserData);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
when(_userDataDao.findByUserData(account.getAccountId(), account.getDomainId(), testUserData)).thenReturn(null);
when(userDataManager.validateUserData(testUserData, BaseCmd.HTTPMethod.GET)).thenReturn(testUserData);
UserData userData = spy.registerUserData(cmd);
Assert.assertEquals("testName", userData.getName());
Assert.assertEquals("testUserdata", userData.getUserData());
Assert.assertEquals(1L, userData.getAccountId());
Assert.assertEquals(2L, userData.getDomainId());
UserData userData = spy.registerUserData(cmd);
Assert.assertEquals("testName", userData.getName());
Assert.assertEquals("testUserdata", userData.getUserData());
Assert.assertEquals(1L, userData.getAccountId());
Assert.assertEquals(2L, userData.getDomainId());
}
}
@Test(expected = InvalidParameterValueException.class)
public void testRegisterExistingUserdata() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
RegisterUserDataCmd cmd = Mockito.mock(RegisterUserDataCmd.class);
when(cmd.getUserData()).thenReturn("testUserdata");
when(cmd.getName()).thenReturn("testName");
RegisterUserDataCmd cmd = Mockito.mock(RegisterUserDataCmd.class);
when(cmd.getUserData()).thenReturn("testUserdata");
when(cmd.getName()).thenReturn("testName");
UserDataVO userData = Mockito.mock(UserDataVO.class);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
when(_userDataDao.findByUserData(account.getAccountId(), account.getDomainId(), "testUserdata")).thenReturn(userData);
UserDataVO userData = Mockito.mock(UserDataVO.class);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
when(_userDataDao.findByUserData(account.getAccountId(), account.getDomainId(), "testUserdata")).thenReturn(userData);
spy.registerUserData(cmd);
spy.registerUserData(cmd);
}
}
@Test(expected = InvalidParameterValueException.class)
public void testRegisterExistingName() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
PowerMockito.when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
Mockito.when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
RegisterUserDataCmd cmd = Mockito.mock(RegisterUserDataCmd.class);
when(cmd.getUserData()).thenReturn("testUserdata");
when(cmd.getName()).thenReturn("testName");
RegisterUserDataCmd cmd = Mockito.mock(RegisterUserDataCmd.class);
when(cmd.getName()).thenReturn("testName");
UserDataVO userData = Mockito.mock(UserDataVO.class);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(userData);
UserDataVO userData = Mockito.mock(UserDataVO.class);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(userData);
spy.registerUserData(cmd);
spy.registerUserData(cmd);
}
}
@Test
public void testSuccessfulDeleteUserdata() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
DeleteUserDataCmd cmd = Mockito.mock(DeleteUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
UserDataVO userData = Mockito.mock(UserDataVO.class);
DeleteUserDataCmd cmd = Mockito.mock(DeleteUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
UserDataVO userData = Mockito.mock(UserDataVO.class);
Mockito.when(userData.getId()).thenReturn(1L);
when(_userDataDao.findById(1L)).thenReturn(userData);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
when(_templateDao.findTemplatesLinkedToUserdata(1L)).thenReturn(new ArrayList<VMTemplateVO>());
when(_userVmDao.findByUserDataId(1L)).thenReturn(new ArrayList<UserVmVO>());
when(_userDataDao.remove(1L)).thenReturn(true);
Mockito.when(userData.getId()).thenReturn(1L);
when(_userDataDao.findById(1L)).thenReturn(userData);
when(_templateDao.findTemplatesLinkedToUserdata(1L)).thenReturn(new ArrayList<VMTemplateVO>());
when(_userVmDao.findByUserDataId(1L)).thenReturn(new ArrayList<UserVmVO>());
when(_userDataDao.remove(1L)).thenReturn(true);
boolean result = spy.deleteUserData(cmd);
Assert.assertEquals(true, result);
boolean result = spy.deleteUserData(cmd);
Assert.assertEquals(true, result);
}
}
@Test(expected = CloudRuntimeException.class)
public void testDeleteUserdataLinkedToTemplate() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
DeleteUserDataCmd cmd = Mockito.mock(DeleteUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
DeleteUserDataCmd cmd = Mockito.mock(DeleteUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
UserDataVO userData = Mockito.mock(UserDataVO.class);
Mockito.when(userData.getId()).thenReturn(1L);
when(_userDataDao.findById(1L)).thenReturn(userData);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
UserDataVO userData = Mockito.mock(UserDataVO.class);
Mockito.when(userData.getId()).thenReturn(1L);
when(_userDataDao.findById(1L)).thenReturn(userData);
VMTemplateVO vmTemplateVO = Mockito.mock(VMTemplateVO.class);
List<VMTemplateVO> linkedTemplates = new ArrayList<>();
linkedTemplates.add(vmTemplateVO);
when(_templateDao.findTemplatesLinkedToUserdata(1L)).thenReturn(linkedTemplates);
VMTemplateVO vmTemplateVO = Mockito.mock(VMTemplateVO.class);
List<VMTemplateVO> linkedTemplates = new ArrayList<>();
linkedTemplates.add(vmTemplateVO);
when(_templateDao.findTemplatesLinkedToUserdata(1L)).thenReturn(linkedTemplates);
spy.deleteUserData(cmd);
spy.deleteUserData(cmd);
}
}
@Test(expected = CloudRuntimeException.class)
public void testDeleteUserdataUsedByVM() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
DeleteUserDataCmd cmd = Mockito.mock(DeleteUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
DeleteUserDataCmd cmd = Mockito.mock(DeleteUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
UserDataVO userData = Mockito.mock(UserDataVO.class);
Mockito.when(userData.getId()).thenReturn(1L);
when(_userDataDao.findById(1L)).thenReturn(userData);
when(_userDataDao.findByName(account.getAccountId(), account.getDomainId(), "testName")).thenReturn(null);
UserDataVO userData = Mockito.mock(UserDataVO.class);
Mockito.when(userData.getId()).thenReturn(1L);
when(_userDataDao.findById(1L)).thenReturn(userData);
when(_templateDao.findTemplatesLinkedToUserdata(1L)).thenReturn(new ArrayList<VMTemplateVO>());
when(_templateDao.findTemplatesLinkedToUserdata(1L)).thenReturn(new ArrayList<VMTemplateVO>());
UserVmVO userVmVO = Mockito.mock(UserVmVO.class);
List<UserVmVO> vms = new ArrayList<>();
vms.add(userVmVO);
when(_userVmDao.findByUserDataId(1L)).thenReturn(vms);
UserVmVO userVmVO = Mockito.mock(UserVmVO.class);
List<UserVmVO> vms = new ArrayList<>();
vms.add(userVmVO);
when(_userVmDao.findByUserDataId(1L)).thenReturn(vms);
spy.deleteUserData(cmd);
spy.deleteUserData(cmd);
}
}
@Test
public void testListUserDataById() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);;
ListUserDataCmd cmd = Mockito.mock(ListUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
when(cmd.isRecursive()).thenReturn(false);
UserDataVO userData = Mockito.mock(UserDataVO.class);
ListUserDataCmd cmd = Mockito.mock(ListUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getId()).thenReturn(1L);
when(cmd.isRecursive()).thenReturn(false);
UserDataVO userData = Mockito.mock(UserDataVO.class);
SearchBuilder<UserDataVO> sb = Mockito.mock(SearchBuilder.class);
when(_userDataDao.createSearchBuilder()).thenReturn(sb);
when(sb.entity()).thenReturn(userData);
SearchBuilder<UserDataVO> sb = Mockito.mock(SearchBuilder.class);
when(_userDataDao.createSearchBuilder()).thenReturn(sb);
when(sb.entity()).thenReturn(userData);
SearchCriteria<UserDataVO> sc = Mockito.mock(SearchCriteria.class);
when(sb.create()).thenReturn(sc);
SearchCriteria<UserDataVO> sc = Mockito.mock(SearchCriteria.class);
when(sb.create()).thenReturn(sc);
List<UserDataVO> userDataList = new ArrayList<UserDataVO>();
userDataList.add(userData);
Pair<List<UserDataVO>, Integer> result = new Pair(userDataList, 1);
when(_userDataDao.searchAndCount(nullable(SearchCriteria.class), nullable(Filter.class))).thenReturn(result);
List<UserDataVO> userDataList = new ArrayList<UserDataVO>();
userDataList.add(userData);
Pair<List<UserDataVO>, Integer> result = new Pair(userDataList, 1);
when(_userDataDao.searchAndCount(nullable(SearchCriteria.class), nullable(Filter.class))).thenReturn(result);
Pair<List<? extends UserData>, Integer> userdataResultList = spy.listUserDatas(cmd);
Pair<List<? extends UserData>, Integer> userdataResultList = spy.listUserDatas(cmd);
Assert.assertEquals(userdataResultList.first().get(0), userDataList.get(0));
Assert.assertEquals(userdataResultList.first().get(0), userDataList.get(0));
}
}
@Test
public void testListUserDataByName() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(callContextMock.getCallingAccount()).thenReturn(account);
ListUserDataCmd cmd = Mockito.mock(ListUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getName()).thenReturn("testSearchUserdataName");
when(cmd.isRecursive()).thenReturn(false);
UserDataVO userData = Mockito.mock(UserDataVO.class);
ListUserDataCmd cmd = Mockito.mock(ListUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getName()).thenReturn("testSearchUserdataName");
when(cmd.isRecursive()).thenReturn(false);
UserDataVO userData = Mockito.mock(UserDataVO.class);
SearchBuilder<UserDataVO> sb = Mockito.mock(SearchBuilder.class);
when(_userDataDao.createSearchBuilder()).thenReturn(sb);
when(sb.entity()).thenReturn(userData);
SearchBuilder<UserDataVO> sb = Mockito.mock(SearchBuilder.class);
when(_userDataDao.createSearchBuilder()).thenReturn(sb);
when(sb.entity()).thenReturn(userData);
SearchCriteria<UserDataVO> sc = Mockito.mock(SearchCriteria.class);
when(sb.create()).thenReturn(sc);
SearchCriteria<UserDataVO> sc = Mockito.mock(SearchCriteria.class);
when(sb.create()).thenReturn(sc);
List<UserDataVO> userDataList = new ArrayList<UserDataVO>();
userDataList.add(userData);
Pair<List<UserDataVO>, Integer> result = new Pair(userDataList, 1);
when(_userDataDao.searchAndCount(nullable(SearchCriteria.class), nullable(Filter.class))).thenReturn(result);
List<UserDataVO> userDataList = new ArrayList<UserDataVO>();
userDataList.add(userData);
Pair<List<UserDataVO>, Integer> result = new Pair(userDataList, 1);
when(_userDataDao.searchAndCount(nullable(SearchCriteria.class), nullable(Filter.class))).thenReturn(result);
Pair<List<? extends UserData>, Integer> userdataResultList = spy.listUserDatas(cmd);
Pair<List<? extends UserData>, Integer> userdataResultList = spy.listUserDatas(cmd);
Assert.assertEquals(userdataResultList.first().get(0), userDataList.get(0));
Assert.assertEquals(userdataResultList.first().get(0), userDataList.get(0));
}
}
@Test
public void testListUserDataByKeyword() {
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = PowerMockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(account.getAccountId()).thenReturn(1L);
when(account.getDomainId()).thenReturn(2L);
when(callContextMock.getCallingAccount()).thenReturn(account);
when(_accountMgr.finalizeOwner(nullable(Account.class), nullable(String.class), nullable(Long.class), nullable(Long.class))).thenReturn(account);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
when(CallContext.current()).thenReturn(callContextMock);
when(callContextMock.getCallingAccount()).thenReturn(account);
ListUserDataCmd cmd = Mockito.mock(ListUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getKeyword()).thenReturn("testSearchUserdataKeyword");
when(cmd.isRecursive()).thenReturn(false);
UserDataVO userData = Mockito.mock(UserDataVO.class);
ListUserDataCmd cmd = Mockito.mock(ListUserDataCmd.class);
when(cmd.getAccountName()).thenReturn("testAccountName");
when(cmd.getDomainId()).thenReturn(1L);
when(cmd.getProjectId()).thenReturn(2L);
when(cmd.getKeyword()).thenReturn("testSearchUserdataKeyword");
when(cmd.isRecursive()).thenReturn(false);
UserDataVO userData = Mockito.mock(UserDataVO.class);
SearchBuilder<UserDataVO> sb = Mockito.mock(SearchBuilder.class);
when(_userDataDao.createSearchBuilder()).thenReturn(sb);
when(sb.entity()).thenReturn(userData);
SearchBuilder<UserDataVO> sb = Mockito.mock(SearchBuilder.class);
when(_userDataDao.createSearchBuilder()).thenReturn(sb);
when(sb.entity()).thenReturn(userData);
SearchCriteria<UserDataVO> sc = Mockito.mock(SearchCriteria.class);
when(sb.create()).thenReturn(sc);
SearchCriteria<UserDataVO> sc = Mockito.mock(SearchCriteria.class);
when(sb.create()).thenReturn(sc);
List<UserDataVO> userDataList = new ArrayList<UserDataVO>();
userDataList.add(userData);
Pair<List<UserDataVO>, Integer> result = new Pair(userDataList, 1);
when(_userDataDao.searchAndCount(nullable(SearchCriteria.class), nullable(Filter.class))).thenReturn(result);
List<UserDataVO> userDataList = new ArrayList<UserDataVO>();
userDataList.add(userData);
Pair<List<UserDataVO>, Integer> result = new Pair(userDataList, 1);
when(_userDataDao.searchAndCount(nullable(SearchCriteria.class), nullable(Filter.class))).thenReturn(result);
Pair<List<? extends UserData>, Integer> userdataResultList = spy.listUserDatas(cmd);
Pair<List<? extends UserData>, Integer> userdataResultList = spy.listUserDatas(cmd);
Assert.assertEquals(userdataResultList.first().get(0), userDataList.get(0));
Assert.assertEquals(userdataResultList.first().get(0), userDataList.get(0));
}
}
private UserVmVO mockFilterUefiHostsTestVm(String uefiValue) {

164
server/src/test/java/com/cloud/server/StatsCollectorTest.java
View File

@ -18,40 +18,6 @@
//
package com.cloud.server;
import static org.mockito.Mockito.when;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.commons.collections.CollectionUtils;
import org.influxdb.InfluxDB;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.BatchPoints;
import org.influxdb.dto.BatchPoints.Builder;
import org.influxdb.dto.Point;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import com.cloud.agent.api.VmDiskStatsEntry;
import com.cloud.agent.api.VmStatsEntry;
import com.cloud.hypervisor.Hypervisor;
@ -66,10 +32,41 @@ import com.cloud.vm.dao.VmStatsDao;
import com.google.gson.Gson;
import com.tngtech.java.junit.dataprovider.DataProvider;
import com.tngtech.java.junit.dataprovider.DataProviderRunner;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.commons.collections.CollectionUtils;
import org.influxdb.InfluxDB;
import org.influxdb.InfluxDBFactory;
import org.influxdb.dto.BatchPoints;
import org.influxdb.dto.BatchPoints.Builder;
import org.influxdb.dto.Point;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.stubbing.Answer;
@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(DataProviderRunner.class)
@PrepareForTest({InfluxDBFactory.class, BatchPoints.class})
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import static org.mockito.Mockito.when;
@RunWith(DataProviderRunner.class)
public class StatsCollectorTest {
@InjectMocks
@ -83,31 +80,50 @@ public class StatsCollectorTest {
private static final String DEFAULT_DATABASE_NAME = "cloudstack";
@Mock
VmStatsDao vmStatsDaoMock;
VmStatsDao vmStatsDaoMock = Mockito.mock(VmStatsDao.class);
@Mock
VmStatsEntry statsForCurrentIterationMock;
@Captor
ArgumentCaptor<VmStatsVO> vmStatsVOCaptor;
ArgumentCaptor<VmStatsVO> vmStatsVOCaptor = ArgumentCaptor.forClass(VmStatsVO.class);
@Captor
ArgumentCaptor<Boolean> booleanCaptor;
ArgumentCaptor<Boolean> booleanCaptor = ArgumentCaptor.forClass(Boolean.class);
@Mock
Boolean accumulateMock;
VmStatsVO vmStatsVoMock1 = Mockito.mock(VmStatsVO.class);
@Mock
VmStatsVO vmStatsVoMock1, vmStatsVoMock2;
VmStatsVO vmStatsVoMock2 = Mockito.mock(VmStatsVO.class);
@Mock
VmStatsEntry vmStatsEntryMock;
VmStatsEntry vmStatsEntryMock = Mockito.mock(VmStatsEntry.class);
@Mock
VolumeStatsDao volumeStatsDao;
VolumeStatsDao volumeStatsDao = Mockito.mock(VolumeStatsDao.class);
private static Gson gson = new Gson();
private MockedStatic<InfluxDBFactory> influxDBFactoryMocked;
private AutoCloseable closeable;
@Before
public void setUp() throws Exception {
closeable = MockitoAnnotations.openMocks(this);
statsCollector.vmStatsDao = vmStatsDaoMock;
statsCollector.volumeStatsDao = volumeStatsDao;
}
@After
public void tearDown() throws Exception {
if (influxDBFactoryMocked != null) {
influxDBFactoryMocked.close();
}
closeable.close();
}
@Test
public void createInfluxDbConnectionTest() {
configureAndTestCreateInfluxDbConnection(true);
@ -123,8 +139,8 @@ public class StatsCollectorTest {
statsCollector.externalStatsPort = INFLUXDB_DEFAULT_PORT;
InfluxDB influxDbConnection = Mockito.mock(InfluxDB.class);
when(influxDbConnection.databaseExists(DEFAULT_DATABASE_NAME)).thenReturn(databaseExists);
PowerMockito.mockStatic(InfluxDBFactory.class);
PowerMockito.when(InfluxDBFactory.connect(URL)).thenReturn(influxDbConnection);
influxDBFactoryMocked = Mockito.mockStatic(InfluxDBFactory.class);
influxDBFactoryMocked.when(() -> InfluxDBFactory.connect(URL)).thenReturn(influxDbConnection);
InfluxDB returnedConnection = statsCollector.createInfluxDbConnection();
@ -137,21 +153,22 @@ public class StatsCollectorTest {
Mockito.doNothing().when(influxDbConnection).write(Mockito.any(Point.class));
Builder builder = Mockito.mock(Builder.class);
BatchPoints batchPoints = Mockito.mock(BatchPoints.class);
PowerMockito.mockStatic(BatchPoints.class);
PowerMockito.when(BatchPoints.database(DEFAULT_DATABASE_NAME)).thenReturn(builder);
when(builder.build()).thenReturn(batchPoints);
Map<String, String> tagsToAdd = new HashMap<>();
tagsToAdd.put("hostId", "1");
Map<String, Object> fieldsToAdd = new HashMap<>();
fieldsToAdd.put("total_memory_kbs", 10000000);
Point point = Point.measurement("measure").tag(tagsToAdd).time(System.currentTimeMillis(), TimeUnit.MILLISECONDS).fields(fieldsToAdd).build();
List<Point> points = new ArrayList<>();
points.add(point);
when(batchPoints.point(point)).thenReturn(batchPoints);
try (MockedStatic<BatchPoints> ignored = Mockito.mockStatic(BatchPoints.class)) {
Mockito.when(BatchPoints.database(DEFAULT_DATABASE_NAME)).thenReturn(builder);
when(builder.build()).thenReturn(batchPoints);
Map<String, String> tagsToAdd = new HashMap<>();
tagsToAdd.put("hostId", "1");
Map<String, Object> fieldsToAdd = new HashMap<>();
fieldsToAdd.put("total_memory_kbs", 10000000);
Point point = Point.measurement("measure").tag(tagsToAdd).time(System.currentTimeMillis(), TimeUnit.MILLISECONDS).fields(fieldsToAdd).build();
List<Point> points = new ArrayList<>();
points.add(point);
when(batchPoints.point(point)).thenReturn(batchPoints);
statsCollector.writeBatches(influxDbConnection, DEFAULT_DATABASE_NAME, points);
statsCollector.writeBatches(influxDbConnection, DEFAULT_DATABASE_NAME, points);
Mockito.verify(influxDbConnection).write(batchPoints);
Mockito.verify(influxDbConnection).write(batchPoints);
}
}
@Test
@ -232,7 +249,8 @@ public class StatsCollectorTest {
configureAndTestisCurrentVmDiskStatsDifferentFromPrevious(123l, 123l, 123l, 123l, false);
}
private void configureAndTestisCurrentVmDiskStatsDifferentFromPrevious(long bytesRead, long bytesWrite, long ioRead, long ioWrite, boolean expectedResult) {
private void configureAndTestisCurrentVmDiskStatsDifferentFromPrevious(long bytesRead, long bytesWrite, long ioRead,
long ioWrite, boolean expectedResult) {
VmDiskStatisticsVO previousVmDiskStatisticsVO = new VmDiskStatisticsVO(1l, 1l, 1l, 1l);
previousVmDiskStatisticsVO.setCurrentBytesRead(123l);
previousVmDiskStatisticsVO.setCurrentBytesWrite(123l);
@ -251,12 +269,13 @@ public class StatsCollectorTest {
@Test
@DataProvider({
"0,0,0,0,true", "1,0,0,0,false", "0,1,0,0,false", "0,0,1,0,false",
"0,0,0,1,false", "1,0,0,1,false", "1,0,1,0,false", "1,1,0,0,false",
"0,1,1,0,false", "0,1,0,1,false", "0,0,1,1,false", "0,1,1,1,false",
"1,1,0,1,false", "1,0,1,1,false", "1,1,1,0,false", "1,1,1,1,false",
"0,0,0,0,true", "1,0,0,0,false", "0,1,0,0,false", "0,0,1,0,false",
"0,0,0,1,false", "1,0,0,1,false", "1,0,1,0,false", "1,1,0,0,false",
"0,1,1,0,false", "0,1,0,1,false", "0,0,1,1,false", "0,1,1,1,false",
"1,1,0,1,false", "1,0,1,1,false", "1,1,1,0,false", "1,1,1,1,false",
})
public void configureAndTestCheckIfDiskStatsAreZero(long bytesRead, long bytesWrite, long ioRead, long ioWrite, boolean expected) {
public void configureAndTestCheckIfDiskStatsAreZero(long bytesRead, long bytesWrite, long ioRead, long ioWrite,
boolean expected) {
VmDiskStatsEntry vmDiskStatsEntry = new VmDiskStatsEntry();
vmDiskStatsEntry.setBytesRead(bytesRead);
vmDiskStatsEntry.setBytesWrite(bytesWrite);
@ -318,10 +337,9 @@ public class StatsCollectorTest {
@Test
public void getVmStatsTestWithAccumulateNotNull() {
Mockito.doReturn(Arrays.asList(vmStatsVoMock1)).when(vmStatsDaoMock).findByVmIdOrderByTimestampDesc(Mockito.anyLong());
Mockito.doReturn(true).when(accumulateMock).booleanValue();
Mockito.doReturn(vmStatsEntryMock).when(statsCollector).getLatestOrAccumulatedVmMetricsStats(Mockito.anyList(), Mockito.anyBoolean());
VmStats result = statsCollector.getVmStats(1L, accumulateMock);
VmStats result = statsCollector.getVmStats(1L, false);
Mockito.verify(statsCollector).getLatestOrAccumulatedVmMetricsStats(Mockito.anyList(), booleanCaptor.capture());
boolean actualArg = booleanCaptor.getValue().booleanValue();
@ -369,8 +387,8 @@ public class StatsCollectorTest {
+ "\"networkWriteKBs\":1.1,\"diskReadIOs\":3.0,\"diskWriteIOs\":3.1,\"diskReadKBs\":2.0,"
+ "\"diskWriteKBs\":2.1,\"memoryKBs\":1.0,\"intFreeMemoryKBs\":1.0,"
+ "\"targetMemoryKBs\":1.0,\"numCPUs\":1,\"entityType\":\"vm\"}";
Mockito.doReturn(fakeStatsData1).when(vmStatsVoMock1).getVmStatsData();
Mockito.doReturn(fakeStatsData2).when(vmStatsVoMock2).getVmStatsData();
Mockito.when(vmStatsVoMock1.getVmStatsData()).thenReturn(fakeStatsData1);
Mockito.when(vmStatsVoMock2.getVmStatsData()).thenReturn(fakeStatsData2);
VmStatsEntry result = statsCollector.accumulateVmMetricsStats(new ArrayList<VmStatsVO>(
Arrays.asList(vmStatsVoMock1, vmStatsVoMock2)));
@ -398,6 +416,7 @@ public class StatsCollectorTest {
Assert.assertTrue(statsCollector.isDbLocal());
}
@Test
public void testIsDbIpv4Local() {
Properties p = new Properties();
@ -406,6 +425,7 @@ public class StatsCollectorTest {
Assert.assertTrue(statsCollector.isDbLocal());
}
@Test
public void testIsDbSymbolicLocal() {
Properties p = new Properties();
@ -414,6 +434,7 @@ public class StatsCollectorTest {
Assert.assertTrue(statsCollector.isDbLocal());
}
@Test
public void testIsDbOnSameIp() {
Properties p = new Properties();
@ -423,6 +444,7 @@ public class StatsCollectorTest {
Assert.assertTrue(statsCollector.isDbLocal());
}
@Test
public void testIsDbNotLocal() {
Properties p = new Properties();
@ -435,7 +457,7 @@ public class StatsCollectorTest {
private void performPersistVolumeStatsTest(Hypervisor.HypervisorType hypervisorType) {
Date timestamp = new Date();
String vmName= "vm";
String vmName = "vm";
String path = "path";
long ioReadDiff = 100;
long ioWriteDiff = 200;
@ -462,7 +484,7 @@ public class StatsCollectorTest {
}
List<VolumeStatsVO> persistedStats = new ArrayList<>();
Mockito.when(volumeStatsDao.persist(Mockito.any(VolumeStatsVO.class))).thenAnswer((Answer<VolumeStatsVO>) invocation -> {
VolumeStatsVO statsVO = (VolumeStatsVO)invocation.getArguments()[0];
VolumeStatsVO statsVO = (VolumeStatsVO) invocation.getArguments()[0];
persistedStats.add(statsVO);
return statsVO;
});

19
server/src/test/java/com/cloud/snapshot/SnapshotDaoTest.java
View File

@ -16,23 +16,20 @@
// under the License.
package com.cloud.snapshot;
import java.util.List;
import javax.inject.Inject;
import com.cloud.storage.Snapshot;
import com.cloud.storage.SnapshotVO;
import com.cloud.storage.dao.SnapshotDaoImpl;
import com.cloud.utils.component.ComponentContext;
import junit.framework.Assert;
import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.cloud.storage.Snapshot;
import com.cloud.storage.SnapshotVO;
import com.cloud.storage.dao.SnapshotDaoImpl;
import com.cloud.utils.component.ComponentContext;
import junit.framework.Assert;
import junit.framework.TestCase;
import javax.inject.Inject;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/SnapshotDaoTestContext.xml")

22
server/src/test/java/com/cloud/snapshot/SnapshotDaoTestConfiguration.java
View File

@ -17,18 +17,6 @@
package com.cloud.snapshot;
import java.io.IOException;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.apache.cloudstack.test.utils.SpringUtils;
import com.cloud.cluster.agentlb.dao.HostTransferMapDaoImpl;
import com.cloud.dc.dao.ClusterDaoImpl;
import com.cloud.dc.dao.HostPodDaoImpl;
@ -40,6 +28,16 @@ import com.cloud.storage.dao.VolumeDaoImpl;
import com.cloud.tags.dao.ResourceTagsDaoImpl;
import com.cloud.vm.dao.NicDaoImpl;
import com.cloud.vm.dao.VMInstanceDaoImpl;
import org.apache.cloudstack.test.utils.SpringUtils;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import java.io.IOException;
@Configuration
@ComponentScan(basePackageClasses = {SnapshotDaoImpl.class, ResourceTagsDaoImpl.class, VMInstanceDaoImpl.class, VolumeDaoImpl.class, NicDaoImpl.class, HostDaoImpl.class,

15
server/src/test/java/com/cloud/storage/ImageStoreDetailsUtilTest.java
View File

@ -16,13 +16,7 @@
// under the License.
package com.cloud.storage;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.HashMap;
import java.util.Map;
import com.cloud.capacity.CapacityManager;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.config.impl.ConfigurationVO;
import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
@ -31,7 +25,12 @@ import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
import org.junit.Before;
import org.junit.Test;
import com.cloud.capacity.CapacityManager;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ImageStoreDetailsUtilTest {

15
server/src/test/java/com/cloud/storage/StorageManagerImplTest.java
View File

@ -16,9 +16,11 @@
// under the License.
package com.cloud.storage;
import java.util.ArrayList;
import java.util.List;
import com.cloud.agent.api.StoragePoolInfo;
import com.cloud.host.Host;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.dao.VMInstanceDao;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -28,11 +30,8 @@ import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.agent.api.StoragePoolInfo;
import com.cloud.host.Host;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.dao.VMInstanceDao;
import java.util.ArrayList;
import java.util.List;
@RunWith(MockitoJUnitRunner.class)
public class StorageManagerImplTest {

262
server/src/test/java/com/cloud/storage/VolumeApiServiceImplTest.java
View File

@ -16,27 +16,53 @@
// under the License.
package com.cloud.storage;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import com.cloud.api.query.dao.ServiceOfferingJoinDao;
import com.cloud.api.query.vo.ServiceOfferingJoinVO;
import com.cloud.configuration.Resource;
import com.cloud.configuration.Resource.ResourceType;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventUtils;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.host.HostVO;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.org.Grouping;
import com.cloud.projects.Project;
import com.cloud.projects.ProjectManager;
import com.cloud.serializer.GsonHelper;
import com.cloud.server.TaggedResourceService;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.Storage.ProvisioningType;
import com.cloud.storage.Volume.Type;
import com.cloud.storage.dao.DiskOfferingDao;
import com.cloud.storage.dao.SnapshotDao;
import com.cloud.storage.dao.StoragePoolTagsDao;
import com.cloud.storage.dao.VMTemplateDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.storage.snapshot.SnapshotManager;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.db.TransactionLegacy;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.fsm.NoTransitionException;
import com.cloud.vm.UserVmManager;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachine.State;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.cloud.vm.snapshot.VMSnapshotVO;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.command.user.volume.CreateVolumeCmd;
@ -75,64 +101,33 @@ import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import com.cloud.api.query.dao.ServiceOfferingJoinDao;
import com.cloud.api.query.vo.ServiceOfferingJoinVO;
import com.cloud.configuration.Resource;
import com.cloud.configuration.Resource.ResourceType;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventUtils;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.host.HostVO;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.org.Grouping;
import com.cloud.projects.Project;
import com.cloud.projects.ProjectManager;
import com.cloud.serializer.GsonHelper;
import com.cloud.server.TaggedResourceService;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.Storage.ProvisioningType;
import com.cloud.storage.Volume.Type;
import com.cloud.storage.dao.DiskOfferingDao;
import com.cloud.storage.dao.SnapshotDao;
import com.cloud.storage.dao.StoragePoolTagsDao;
import com.cloud.storage.dao.VMTemplateDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.storage.snapshot.SnapshotManager;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.db.TransactionLegacy;
import com.cloud.utils.fsm.NoTransitionException;
import com.cloud.vm.UserVmManager;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachine.State;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.cloud.vm.snapshot.VMSnapshotVO;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
@RunWith(PowerMockRunner.class)
@PowerMockIgnore("javax.management.*")
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class VolumeApiServiceImplTest {
@Spy
@ -545,9 +540,9 @@ public class VolumeApiServiceImplTest {
when(volumeInfoMock.getState()).thenReturn(Volume.State.Ready);
when(volumeInfoMock.getInstanceId()).thenReturn(null);
when(volumeInfoMock.getPoolId()).thenReturn(1L);
when(volumeServiceMock.takeSnapshot(Mockito.any(VolumeInfo.class))).thenReturn(snapshotInfoMock);
when(volumeServiceMock.takeSnapshot(any(VolumeInfo.class))).thenReturn(snapshotInfoMock);
final TaggedResourceService taggedResourceService = Mockito.mock(TaggedResourceService.class);
Mockito.lenient().when(taggedResourceService.createTags(anyObject(), anyObject(), anyObject(), anyObject())).thenReturn(null);
Mockito.lenient().when(taggedResourceService.createTags(any(), any(), any(), any())).thenReturn(null);
ReflectionTestUtils.setField(volumeApiServiceImpl, "taggedResourceService", taggedResourceService);
volumeApiServiceImpl.takeSnapshot(5L, Snapshot.MANUAL_POLICY_ID, 3L, null, false, null, false, null);
}
@ -1320,11 +1315,11 @@ public class VolumeApiServiceImplTest {
ServiceOfferingJoinVO serviceOfferingJoinVO = Mockito.mock(ServiceOfferingJoinVO.class);
when(serviceOfferingJoinVO.getRootDiskSize()).thenReturn(rootDisk);
when(serviceOfferingJoinDao.findById(Mockito.anyLong())).thenReturn(serviceOfferingJoinVO);
when(serviceOfferingJoinDao.findById(anyLong())).thenReturn(serviceOfferingJoinVO);
VMTemplateVO template = Mockito.mock(VMTemplateVO.class);
when(template.getFormat()).thenReturn(imageFormat);
when(templateDao.findByIdIncludingRemoved(Mockito.anyLong())).thenReturn(template);
when(templateDao.findByIdIncludingRemoved(anyLong())).thenReturn(template);
boolean result = volumeApiServiceImpl.isNotPossibleToResize(volume, diskOffering);
Assert.assertEquals(expectedIsNotPossibleToResize, result);
@ -1343,27 +1338,27 @@ public class VolumeApiServiceImplTest {
}
@Test (expected = PermissionDeniedException.class)
@PrepareForTest (CollectionUtils.class)
public void checkIfVolumeCanBeReassignedTestVolumeWithSnapshots() {
Mockito.doReturn(null).when(volumeVoMock).getInstanceId();
Mockito.doReturn(snapshotVOArrayListMock).when(snapshotDaoMock).listByStatusNotIn(Mockito.anyLong(), Mockito.any(), Mockito.any());
Mockito.doReturn(snapshotVOArrayListMock).when(snapshotDaoMock).listByStatusNotIn(anyLong(), any(), any());
PowerMockito.mockStatic(CollectionUtils.class);
PowerMockito.when(CollectionUtils.isNotEmpty(snapshotVOArrayListMock)).thenReturn(true);
try (MockedStatic<CollectionUtils> ignored = Mockito.mockStatic(CollectionUtils.class)) {
Mockito.when(CollectionUtils.isNotEmpty(snapshotVOArrayListMock)).thenReturn(true);
volumeApiServiceImpl.validateVolume(volumeVoMock.getUuid(), volumeVoMock);
volumeApiServiceImpl.validateVolume(volumeVoMock.getUuid(), volumeVoMock);
}
}
@Test
@PrepareForTest (CollectionUtils.class)
public void checkIfVolumeCanBeReassignedTestValidVolume() {
Mockito.doReturn(null).when(volumeVoMock).getInstanceId();
Mockito.doReturn(snapshotVOArrayListMock).when(snapshotDaoMock).listByStatusNotIn(Mockito.anyLong(), Mockito.any(), Mockito.any());
Mockito.doReturn(snapshotVOArrayListMock).when(snapshotDaoMock).listByStatusNotIn(anyLong(), any(), any());
PowerMockito.mockStatic(CollectionUtils.class);
PowerMockito.when(CollectionUtils.isNotEmpty(snapshotVOArrayListMock)).thenReturn(false);
try (MockedStatic<CollectionUtils> ignored = Mockito.mockStatic(CollectionUtils.class)) {
Mockito.when(CollectionUtils.isNotEmpty(snapshotVOArrayListMock)).thenReturn(false);
volumeApiServiceImpl.validateVolume(volumeVoMock.getUuid(), volumeVoMock);
volumeApiServiceImpl.validateVolume(volumeVoMock.getUuid(), volumeVoMock);
}
}
@Test (expected = InvalidParameterValueException.class)
@ -1378,13 +1373,11 @@ public class VolumeApiServiceImplTest {
@Test (expected = InvalidParameterValueException.class)
public void validateAccountsTestDisabledNewAccount() {
Mockito.doReturn(Account.State.DISABLED).when(accountMock).getState();
volumeApiServiceImpl.validateAccounts(accountMock.getUuid(), volumeVoMock, null, accountMock);
}
@Test (expected = InvalidParameterValueException.class)
public void validateAccountsTestLockedNewAccount() {
Mockito.doReturn(Account.State.LOCKED).when(accountMock).getState();
volumeApiServiceImpl.validateAccounts(accountMock.getUuid(), volumeVoMock, null, accountMock);
}
@ -1400,35 +1393,33 @@ public class VolumeApiServiceImplTest {
}
@Test
@PrepareForTest(UsageEventUtils.class)
public void updateVolumeAccountTest() {
PowerMockito.mockStatic(UsageEventUtils.class);
Account newAccountMock = new AccountVO(accountMockId+1);
try (MockedStatic<UsageEventUtils> usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class)) {
Account newAccountMock = new AccountVO(accountMockId + 1);
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).persist(volumeVoMock);
Mockito.doReturn(volumeVoMock).when(volumeDaoMock).persist(volumeVoMock);
volumeApiServiceImpl.updateVolumeAccount(accountMock, volumeVoMock, newAccountMock);
volumeApiServiceImpl.updateVolumeAccount(accountMock, volumeVoMock, newAccountMock);
PowerMockito.verifyStatic(UsageEventUtils.class);
UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_DELETE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(),
volumeVoMock.getName(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplayVolume());
usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_DELETE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(),
volumeVoMock.getName(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplayVolume()));
Mockito.verify(resourceLimitServiceMock).decrementResourceCount(accountMock.getAccountId(), ResourceType.volume, ByteScaleUtils.bytesToGibibytes(volumeVoMock.getSize()));
Mockito.verify(resourceLimitServiceMock).decrementResourceCount(accountMock.getAccountId(), ResourceType.primary_storage, volumeVoMock.getSize());
Mockito.verify(resourceLimitServiceMock).decrementResourceCount(accountMock.getAccountId(), ResourceType.volume, ByteScaleUtils.bytesToGibibytes(volumeVoMock.getSize()));
Mockito.verify(resourceLimitServiceMock).decrementResourceCount(accountMock.getAccountId(), ResourceType.primary_storage, volumeVoMock.getSize());
Mockito.verify(volumeVoMock).setAccountId(newAccountMock.getAccountId());
Mockito.verify(volumeVoMock).setDomainId(newAccountMock.getDomainId());
Mockito.verify(volumeVoMock).setAccountId(newAccountMock.getAccountId());
Mockito.verify(volumeVoMock).setDomainId(newAccountMock.getDomainId());
Mockito.verify(volumeDaoMock).persist(volumeVoMock);
Mockito.verify(volumeDaoMock).persist(volumeVoMock);
Mockito.verify(resourceLimitServiceMock).incrementResourceCount(newAccountMock.getAccountId(), ResourceType.volume, ByteScaleUtils.bytesToGibibytes(volumeVoMock.getSize()));
Mockito.verify(resourceLimitServiceMock).incrementResourceCount(newAccountMock.getAccountId(), ResourceType.primary_storage, volumeVoMock.getSize());
Mockito.verify(resourceLimitServiceMock).incrementResourceCount(newAccountMock.getAccountId(), ResourceType.volume, ByteScaleUtils.bytesToGibibytes(volumeVoMock.getSize()));
Mockito.verify(resourceLimitServiceMock).incrementResourceCount(newAccountMock.getAccountId(), ResourceType.primary_storage, volumeVoMock.getSize());
PowerMockito.verifyStatic(UsageEventUtils.class);
UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_DELETE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(),
volumeVoMock.getName(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplayVolume());
usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_DELETE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(),
volumeVoMock.getName(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplayVolume()));
Mockito.verify(volumeServiceMock).moveVolumeOnSecondaryStorageToAnotherAccount(volumeVoMock, accountMock, newAccountMock);
Mockito.verify(volumeServiceMock).moveVolumeOnSecondaryStorageToAnotherAccount(volumeVoMock, accountMock, newAccountMock);
}
}
@ -1463,67 +1454,59 @@ public class VolumeApiServiceImplTest {
}
@Test
@PrepareForTest(UsageEventUtils.class)
public void publishVolumeCreationUsageEventTestNullDiskOfferingId() {
Mockito.doReturn(null).when(volumeVoMock).getDiskOfferingId();
PowerMockito.mockStatic(UsageEventUtils.class);
try (MockedStatic<UsageEventUtils> usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class)) {
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
PowerMockito.verifyStatic(UsageEventUtils.class);
UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
null, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay());
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
null, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay()));
}
}
@Test
@PrepareForTest(UsageEventUtils.class)
public void publishVolumeCreationUsageEventTestNullDiskOfferingVo() {
Mockito.doReturn(diskOfferingMockId).when(volumeVoMock).getDiskOfferingId();
Mockito.doReturn(null).when(_diskOfferingDao).findById(diskOfferingMockId);
PowerMockito.mockStatic(UsageEventUtils.class);
try (MockedStatic<UsageEventUtils> usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class)) {
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
PowerMockito.verifyStatic(UsageEventUtils.class);
UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
null, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay());
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
null, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay()));
}
}
@Test
@PrepareForTest(UsageEventUtils.class)
public void publishVolumeCreationUsageEventTestDiskOfferingVoTypeNotDisk() {
Mockito.doReturn(diskOfferingMockId).when(volumeVoMock).getDiskOfferingId();
Mockito.doReturn(newDiskOfferingMock).when(_diskOfferingDao).findById(diskOfferingMockId);
Mockito.doReturn(true).when(newDiskOfferingMock).isComputeOnly();
PowerMockito.mockStatic(UsageEventUtils.class);
try (MockedStatic<UsageEventUtils> usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class)) {
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
PowerMockito.verifyStatic(UsageEventUtils.class);
UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
null, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay());
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
null, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay()));
}
}
@Test
@PrepareForTest(UsageEventUtils.class)
public void publishVolumeCreationUsageEventTestOfferingIdNotNull() {
Mockito.doReturn(diskOfferingMockId).when(volumeVoMock).getDiskOfferingId();
Mockito.doReturn(newDiskOfferingMock).when(_diskOfferingDao).findById(diskOfferingMockId);
Mockito.doReturn(false).when(newDiskOfferingMock).isComputeOnly();
Mockito.doReturn(offeringMockId).when(newDiskOfferingMock).getId();
PowerMockito.mockStatic(UsageEventUtils.class);
try (MockedStatic<UsageEventUtils> usageEventUtilsMocked = Mockito.mockStatic(UsageEventUtils.class)) {
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
PowerMockito.verifyStatic(UsageEventUtils.class);
UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
offeringMockId, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay());
volumeApiServiceImpl.publishVolumeCreationUsageEvent(volumeVoMock);
usageEventUtilsMocked.verify(() -> UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volumeVoMock.getAccountId(), volumeVoMock.getDataCenterId(), volumeVoMock.getId(), volumeVoMock.getName(),
offeringMockId, volumeVoMock.getTemplateId(), volumeVoMock.getSize(), Volume.class.getName(), volumeVoMock.getUuid(), volumeVoMock.isDisplay()));
}
}
private void testBaseListOrderedHostsHypervisorVersionInDc(List<String> hwVersions, HypervisorType hypervisorType,
@ -1603,7 +1586,6 @@ public class VolumeApiServiceImplTest {
Mockito.when(migrateVolumeCmd.getStoragePoolId()).thenReturn(2L);
VolumeVO vol = Mockito.mock(VolumeVO.class);
Mockito.when(volumeDaoMock.findById(1L)).thenReturn(vol);
Mockito.when(volumeDaoMock.getHypervisorType(1L)).thenReturn(HypervisorType.KVM);
Mockito.when(vol.getState()).thenReturn(Volume.State.Ready);
Mockito.when(vol.getPoolId()).thenReturn(1L);
Mockito.when(vol.getInstanceId()).thenReturn(null);
@ -1619,10 +1601,6 @@ public class VolumeApiServiceImplTest {
Mockito.when(primaryDataStoreDaoMock.findById(1L)).thenReturn(srcStoragePoolVOMock);
Mockito.when(srcStoragePoolVOMock.getPoolType()).thenReturn(Storage.StoragePoolType.PowerFlex);
Mockito.when(dataStoreMgr.getDataStore(2L, DataStoreRole.Primary)).thenReturn( dataStore);
Mockito.doNothing().when(snapshotHelper).checkKvmVolumeSnapshotsOnlyInPrimaryStorage(vol, HypervisorType.KVM);
Mockito.when(destPool.getUuid()).thenReturn("bd525970-3d2a-4230-880d-261892129ef3");
Mockito.when(storageMgr.storagePoolCompatibleWithVolumePool(destPool, vol)).thenReturn(false);
volumeApiServiceImpl.migrateVolume(migrateVolumeCmd);
} catch (InvalidParameterValueException e) {

9
server/src/test/java/com/cloud/storage/dao/StoragePoolDaoTest.java
View File

@ -16,18 +16,15 @@
// under the License.
package com.cloud.storage.dao;
import javax.inject.Inject;
import com.cloud.storage.StoragePoolStatus;
import junit.framework.TestCase;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDaoImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDaoImpl;
import com.cloud.storage.StoragePoolStatus;
import javax.inject.Inject;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/StoragePoolDaoTestContext.xml")

7
server/src/test/java/com/cloud/storage/dao/StoragePoolDaoTestConfiguration.java
View File

@ -17,8 +17,8 @@
package com.cloud.storage.dao;
import java.io.IOException;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDaoImpl;
import org.apache.cloudstack.test.utils.SpringUtils;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
@ -27,8 +27,7 @@ import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDaoImpl;
import org.apache.cloudstack.test.utils.SpringUtils;
import java.io.IOException;
@Configuration
@ComponentScan(basePackageClasses = {PrimaryDataStoreDaoImpl.class, StoragePoolDetailsDaoImpl.class},

19
server/src/test/java/com/cloud/storage/listener/StoragePoolMonitorTest.java
View File

@ -16,16 +16,6 @@
// under the License.
package com.cloud.storage.listener;
import static org.mockito.ArgumentMatchers.nullable;
import java.util.Collections;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import com.cloud.agent.api.StartupRoutingCommand;
import com.cloud.exception.StorageUnavailableException;
import com.cloud.host.HostVO;
@ -33,6 +23,15 @@ import com.cloud.hypervisor.Hypervisor;
import com.cloud.storage.ScopeType;
import com.cloud.storage.StorageManagerImpl;
import com.cloud.storage.StoragePoolStatus;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import java.util.Collections;
import static org.mockito.ArgumentMatchers.nullable;
public class StoragePoolMonitorTest {

246
server/src/test/java/com/cloud/storage/snapshot/SnapshotManagerTest.java
View File

@ -16,23 +16,42 @@
// under the License.
package com.cloud.storage.snapshot;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import com.cloud.configuration.Resource.ResourceType;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.resource.ResourceManager;
import com.cloud.server.TaggedResourceService;
import com.cloud.storage.DataStoreRole;
import com.cloud.storage.ScopeType;
import com.cloud.storage.Snapshot;
import com.cloud.storage.SnapshotPolicyVO;
import com.cloud.storage.SnapshotVO;
import com.cloud.storage.Volume;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.SnapshotDao;
import com.cloud.storage.dao.SnapshotPolicyDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.DateUtil;
import com.cloud.utils.DateUtil.IntervalType;
import com.cloud.utils.db.GlobalLock;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VirtualMachine.State;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.snapshot.VMSnapshot;
import com.cloud.vm.snapshot.VMSnapshotVO;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
import org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine;
@ -57,54 +76,29 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.BDDMockito;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.verification.VerificationMode;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.configuration.Resource.ResourceType;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.resource.ResourceManager;
import com.cloud.server.TaggedResourceService;
import com.cloud.storage.DataStoreRole;
import com.cloud.storage.ScopeType;
import com.cloud.storage.Snapshot;
import com.cloud.storage.SnapshotPolicyVO;
import com.cloud.storage.SnapshotVO;
import com.cloud.storage.Storage.ImageFormat;
import com.cloud.storage.Volume;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.SnapshotDao;
import com.cloud.storage.dao.SnapshotPolicyDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.User;
import com.cloud.user.UserVO;
import com.cloud.utils.DateUtil;
import com.cloud.utils.DateUtil.IntervalType;
import com.cloud.utils.db.GlobalLock;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VirtualMachine.State;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.snapshot.VMSnapshot;
import com.cloud.vm.snapshot.VMSnapshotVO;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@RunWith(PowerMockRunner.class)
@PrepareForTest(GlobalLock.class)
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class SnapshotManagerTest {
@Spy
SnapshotManagerImpl _snapshotMgr = new SnapshotManagerImpl();
@ -195,9 +189,11 @@ public class SnapshotManagerTest {
private static final boolean TEST_SNAPSHOT_POLICY_DISPLAY = true;
private static final boolean TEST_SNAPSHOT_POLICY_ACTIVE = true;
private AutoCloseable closeable;
@Before
public void setup() throws ResourceAllocationException {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
_snapshotMgr._snapshotDao = _snapshotDao;
_snapshotMgr._volsDao = _volumeDao;
_snapshotMgr._vmDao = _vmDao;
@ -218,7 +214,6 @@ public class SnapshotManagerTest {
when(_snapshotDao.findById(anyLong())).thenReturn(snapshotMock);
when(snapshotMock.getVolumeId()).thenReturn(TEST_VOLUME_ID);
when(snapshotMock.isRecursive()).thenReturn(false);
when(_volumeDao.findById(anyLong())).thenReturn(volumeMock);
when(volumeMock.getState()).thenReturn(Volume.State.Ready);
@ -227,12 +222,10 @@ public class SnapshotManagerTest {
when(volumeInfoMock.getState()).thenReturn(Volume.State.Ready);
when(storeMock.getId()).thenReturn(TEST_STORAGE_POOL_ID);
when(snapshotFactory.getSnapshot(anyLong(), Mockito.any(DataStoreRole.class))).thenReturn(snapshotInfoMock);
when(_storageStrategyFactory.getSnapshotStrategy(Mockito.any(SnapshotVO.class), Mockito.eq(SnapshotOperation.BACKUP))).thenReturn(snapshotStrategy);
when(_storageStrategyFactory.getSnapshotStrategy(Mockito.any(SnapshotVO.class), Mockito.eq(SnapshotOperation.REVERT))).thenReturn(snapshotStrategy);
when(_storageStrategyFactory.getSnapshotStrategy(Mockito.any(SnapshotVO.class), Mockito.eq(SnapshotOperation.DELETE))).thenReturn(snapshotStrategy);
when(snapshotFactory.getSnapshot(anyLong(), any(DataStoreRole.class))).thenReturn(snapshotInfoMock);
when(_storageStrategyFactory.getSnapshotStrategy(any(SnapshotVO.class), Mockito.eq(SnapshotOperation.BACKUP))).thenReturn(snapshotStrategy);
when(_storageStrategyFactory.getSnapshotStrategy(any(SnapshotVO.class), Mockito.eq(SnapshotOperation.REVERT))).thenReturn(snapshotStrategy);
doNothing().when(_accountMgr).checkAccess(any(Account.class), any(AccessType.class), any(Boolean.class), any(ControlledEntity.class));
doNothing().when(_snapshotMgr._resourceLimitMgr).checkResourceLimit(any(Account.class), any(ResourceType.class));
doNothing().when(_snapshotMgr._resourceLimitMgr).checkResourceLimit(any(Account.class), any(ResourceType.class), anyLong());
doNothing().when(_snapshotMgr._resourceLimitMgr).decrementResourceCount(anyLong(), any(ResourceType.class), anyLong());
@ -254,8 +247,9 @@ public class SnapshotManagerTest {
}
@After
public void tearDown() {
public void tearDown() throws Exception {
CallContext.unregister();
closeable.close();
}
// vm is destroyed
@ -271,7 +265,6 @@ public class SnapshotManagerTest {
@Test(expected = InvalidParameterValueException.class)
public void testAllocSnapshotF2() throws ResourceAllocationException {
when(_vmDao.findById(anyLong())).thenReturn(vmMock);
when(vmMock.getId()).thenReturn(TEST_VM_ID);
when(vmMock.getState()).thenReturn(State.Stopped);
when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);
when(volumeInfoMock.getInstanceId()).thenReturn(TEST_VM_ID);
@ -320,10 +313,7 @@ public class SnapshotManagerTest {
@Test(expected = InvalidParameterValueException.class)
public void testDeleteSnapshotF1() {
when(snapshotStrategy.deleteSnapshot(TEST_SNAPSHOT_ID)).thenReturn(true);
when(snapshotMock.getState()).thenReturn(Snapshot.State.Destroyed);
when(snapshotMock.getAccountId()).thenReturn(2L);
when(snapshotMock.getDataCenterId()).thenReturn(2L);
_snapshotMgr.deleteSnapshot(TEST_SNAPSHOT_ID);
}
@ -342,9 +332,7 @@ public class SnapshotManagerTest {
public void testRevertSnapshotF2() {
when(_vmDao.findById(anyLong())).thenReturn(vmMock);
when(vmMock.getState()).thenReturn(State.Stopped);
when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.XenServer);
when(volumeMock.getFormat()).thenReturn(ImageFormat.VHD);
doReturn(DataStoreRole.Image).when(snapshotHelperMock).getDataStoreRole(Mockito.any());
doReturn(DataStoreRole.Image).when(snapshotHelperMock).getDataStoreRole(any());
Snapshot snapshot = _snapshotMgr.revertSnapshot(TEST_SNAPSHOT_ID);
Assert.assertNull(snapshot);
}
@ -354,11 +342,9 @@ public class SnapshotManagerTest {
public void testRevertSnapshotF3() {
when(_vmDao.findById(anyLong())).thenReturn(vmMock);
when(vmMock.getState()).thenReturn(State.Stopped);
when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);
when(volumeMock.getFormat()).thenReturn(ImageFormat.QCOW2);
when (snapshotStrategy.revertSnapshot(Mockito.any(SnapshotInfo.class))).thenReturn(true);
when (snapshotStrategy.revertSnapshot(any(SnapshotInfo.class))).thenReturn(true);
when(_volumeDao.update(anyLong(), any(VolumeVO.class))).thenReturn(true);
doReturn(DataStoreRole.Image).when(snapshotHelperMock).getDataStoreRole(Mockito.any());
doReturn(DataStoreRole.Image).when(snapshotHelperMock).getDataStoreRole(any());
Snapshot snapshot = _snapshotMgr.revertSnapshot(TEST_SNAPSHOT_ID);
Assert.assertNotNull(snapshot);
}
@ -378,7 +364,6 @@ public class SnapshotManagerTest {
when(_vmDao.findById(nullable(Long.class))).thenReturn(vmMock);
when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);
when(_vmSnapshotDao.findById(nullable(Long.class))).thenReturn(vmSnapshotMock);
when(snapshotStoreDao.findParent(any(DataStoreRole.class), nullable(Long.class), nullable(Long.class))).thenReturn(null);
when(snapshotFactory.getSnapshot(nullable(Long.class), nullable(DataStore.class))).thenReturn(snapshotInfoMock);
when(storeMock.create(snapshotInfoMock)).thenReturn(snapshotInfoMock);
when(snapshotStoreDao.findByStoreSnapshot(nullable(DataStoreRole.class), nullable(Long.class), nullable(Long.class))).thenReturn(snapshotStoreMock);
@ -397,9 +382,7 @@ public class SnapshotManagerTest {
when(_vmDao.findById(nullable(Long.class))).thenReturn(vmMock);
when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);
when(_vmSnapshotDao.findById(nullable(Long.class))).thenReturn(vmSnapshotMock);
when(snapshotStoreDao.findParent(any(DataStoreRole.class), nullable(Long.class), nullable(Long.class))).thenReturn(snapshotStoreMock);
when(snapshotStoreDao.findByStoreSnapshot(nullable(DataStoreRole.class), nullable(Long.class), nullable(Long.class))).thenReturn(snapshotStoreMock);
when(snapshotStoreMock.getInstallPath()).thenReturn("VM_SNAPSHOT_NAME");
when(vmSnapshotMock.getName()).thenReturn("VM_SNAPSHOT_NAME");
Snapshot snapshot = _snapshotMgr.backupSnapshotFromVmSnapshot(TEST_SNAPSHOT_ID, TEST_VM_ID, TEST_VOLUME_ID, TEST_VM_SNAPSHOT_ID);
Assert.assertNull(snapshot);
@ -430,8 +413,8 @@ public class SnapshotManagerTest {
@Test
public void validateCreateSnapshotPolicy(){
Mockito.doReturn(snapshotPolicyVoInstance).when(snapshotPolicyDaoMock).persist(Mockito.any());
Mockito.doReturn(null).when(snapshotSchedulerMock).scheduleNextSnapshotJob(Mockito.any());
Mockito.doReturn(snapshotPolicyVoInstance).when(snapshotPolicyDaoMock).persist(any());
Mockito.doReturn(null).when(snapshotSchedulerMock).scheduleNextSnapshotJob(any());
SnapshotPolicyVO result = _snapshotMgr.createSnapshotPolicy(TEST_VOLUME_ID, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, TEST_SNAPSHOT_POLICY_INTERVAL,
TEST_SNAPSHOT_POLICY_MAX_SNAPS, TEST_SNAPSHOT_POLICY_DISPLAY);
@ -441,9 +424,9 @@ public class SnapshotManagerTest {
@Test
public void validateUpdateSnapshotPolicy(){
Mockito.doReturn(true).when(snapshotPolicyDaoMock).update(Mockito.anyLong(), Mockito.any());
Mockito.doNothing().when(snapshotSchedulerMock).scheduleOrCancelNextSnapshotJobOnDisplayChange(Mockito.any(), Mockito.anyBoolean());
Mockito.doReturn(true).when(taggedResourceServiceMock).deleteTags(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(true).when(snapshotPolicyDaoMock).update(anyLong(), any());
Mockito.doNothing().when(snapshotSchedulerMock).scheduleOrCancelNextSnapshotJobOnDisplayChange(any(), Mockito.anyBoolean());
Mockito.doReturn(true).when(taggedResourceServiceMock).deleteTags(any(), any(), any());
SnapshotPolicyVO snapshotPolicyVo = new SnapshotPolicyVO(TEST_VOLUME_ID, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, TEST_SNAPSHOT_POLICY_INTERVAL,
TEST_SNAPSHOT_POLICY_MAX_SNAPS, TEST_SNAPSHOT_POLICY_DISPLAY);
@ -457,89 +440,90 @@ public class SnapshotManagerTest {
@Test
public void validateCreateTagsForSnapshotPolicyWithNullTags(){
_snapshotMgr.createTagsForSnapshotPolicy(null, snapshotPolicyVoMock);
Mockito.verify(taggedResourceServiceMock, Mockito.never()).createTags(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(taggedResourceServiceMock, Mockito.never()).createTags(any(), any(), any(), any());
}
@Test
public void validateCreateTagsForSnapshotPolicyWithEmptyTags(){
_snapshotMgr.createTagsForSnapshotPolicy(new HashMap<>(), snapshotPolicyVoMock);
Mockito.verify(taggedResourceServiceMock, Mockito.never()).createTags(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(taggedResourceServiceMock, Mockito.never()).createTags(any(), any(), any(), any());
}
@Test
public void validateCreateTagsForSnapshotPolicyWithValidTags(){
Mockito.doReturn(null).when(taggedResourceServiceMock).createTags(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(null).when(taggedResourceServiceMock).createTags(any(), any(), any(), any());
Map map = new HashMap<>();
map.put("test", "test");
_snapshotMgr.createTagsForSnapshotPolicy(map, snapshotPolicyVoMock);
Mockito.verify(taggedResourceServiceMock, Mockito.times(1)).createTags(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(taggedResourceServiceMock, Mockito.times(1)).createTags(any(), any(), any(), any());
}
@Test(expected = CloudRuntimeException.class)
public void validatePersistSnapshotPolicyLockIsNotAquiredMustThrowException() {
PowerMockito.mockStatic(GlobalLock.class);
BDDMockito.given(GlobalLock.getInternLock(Mockito.anyString())).willReturn(globalLockMock);
Mockito.doReturn(false).when(globalLockMock).lock(Mockito.anyInt());
try (MockedStatic<GlobalLock> ignored = Mockito.mockStatic(GlobalLock.class)) {
BDDMockito.given(GlobalLock.getInternLock(Mockito.anyString())).willReturn(globalLockMock);
Mockito.doReturn(false).when(globalLockMock).lock(Mockito.anyInt());
_snapshotMgr.persistSnapshotPolicy(volumeMock, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, TEST_SNAPSHOT_POLICY_INTERVAL, TEST_SNAPSHOT_POLICY_MAX_SNAPS,
TEST_SNAPSHOT_POLICY_DISPLAY, TEST_SNAPSHOT_POLICY_ACTIVE, mapStringStringMock);
_snapshotMgr.persistSnapshotPolicy(volumeMock, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, TEST_SNAPSHOT_POLICY_INTERVAL, TEST_SNAPSHOT_POLICY_MAX_SNAPS,
TEST_SNAPSHOT_POLICY_DISPLAY, TEST_SNAPSHOT_POLICY_ACTIVE, mapStringStringMock);
}
}
@Test
public void validatePersistSnapshotPolicyLockAquiredCreateSnapshotPolicy() {
PowerMockito.mockStatic(GlobalLock.class);
try (MockedStatic<GlobalLock> ignored = Mockito.mockStatic(GlobalLock.class)) {
BDDMockito.given(GlobalLock.getInternLock(Mockito.anyString())).willReturn(globalLockMock);
Mockito.doReturn(true).when(globalLockMock).lock(Mockito.anyInt());
BDDMockito.given(GlobalLock.getInternLock(Mockito.anyString())).willReturn(globalLockMock);
Mockito.doReturn(true).when(globalLockMock).lock(Mockito.anyInt());
for (IntervalType intervalType : listIntervalTypes) {
for (IntervalType intervalType : listIntervalTypes) {
Mockito.doReturn(null).when(snapshotPolicyDaoMock).findOneByVolumeInterval(Mockito.anyLong(), Mockito.eq(intervalType));
Mockito.doReturn(snapshotPolicyVoInstance).when(_snapshotMgr).createSnapshotPolicy(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.eq(intervalType),
Mockito.anyInt(), Mockito.anyBoolean());
Mockito.doNothing().when(_snapshotMgr).createTagsForSnapshotPolicy(mapStringStringMock, snapshotPolicyVoMock);
Mockito.doReturn(null).when(snapshotPolicyDaoMock).findOneByVolumeInterval(anyLong(), Mockito.eq(intervalType));
Mockito.doReturn(snapshotPolicyVoInstance).when(_snapshotMgr).createSnapshotPolicy(anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.eq(intervalType),
Mockito.anyInt(), Mockito.anyBoolean());
SnapshotPolicyVO result = _snapshotMgr.persistSnapshotPolicy(volumeMock, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, intervalType,
TEST_SNAPSHOT_POLICY_MAX_SNAPS, TEST_SNAPSHOT_POLICY_DISPLAY, TEST_SNAPSHOT_POLICY_ACTIVE, null);
SnapshotPolicyVO result = _snapshotMgr.persistSnapshotPolicy(volumeMock, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, intervalType,
TEST_SNAPSHOT_POLICY_MAX_SNAPS, TEST_SNAPSHOT_POLICY_DISPLAY, TEST_SNAPSHOT_POLICY_ACTIVE, null);
assertSnapshotPolicyResultAgainstPreBuiltInstance(result);
assertSnapshotPolicyResultAgainstPreBuiltInstance(result);
}
VerificationMode timesVerification = Mockito.times(listIntervalTypes.size());
Mockito.verify(_snapshotMgr, timesVerification).createSnapshotPolicy(anyLong(), Mockito.anyString(), Mockito.anyString(), any(DateUtil.IntervalType.class),
Mockito.anyInt(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, Mockito.never()).updateSnapshotPolicy(any(SnapshotPolicyVO.class), Mockito.anyString(), Mockito.anyString(),
any(DateUtil.IntervalType.class), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, timesVerification).createTagsForSnapshotPolicy(any(), any());
}
VerificationMode timesVerification = Mockito.times(listIntervalTypes.size());
Mockito.verify(_snapshotMgr, timesVerification).createSnapshotPolicy(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.any(DateUtil.IntervalType.class),
Mockito.anyInt(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, Mockito.never()).updateSnapshotPolicy(Mockito.any(SnapshotPolicyVO.class), Mockito.anyString(), Mockito.anyString(),
Mockito.any(DateUtil.IntervalType.class), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, timesVerification).createTagsForSnapshotPolicy(Mockito.any(), Mockito.any());
}
@Test
public void validatePersistSnapshotPolicyLockAquiredUpdateSnapshotPolicy() {
PowerMockito.mockStatic(GlobalLock.class);
try (MockedStatic<GlobalLock> ignored = Mockito.mockStatic(GlobalLock.class)) {
BDDMockito.given(GlobalLock.getInternLock(Mockito.anyString())).willReturn(globalLockMock);
Mockito.doReturn(true).when(globalLockMock).lock(Mockito.anyInt());
BDDMockito.given(GlobalLock.getInternLock(Mockito.anyString())).willReturn(globalLockMock);
Mockito.doReturn(true).when(globalLockMock).lock(Mockito.anyInt());
for (IntervalType intervalType : listIntervalTypes) {
Mockito.doReturn(snapshotPolicyVoInstance).when(snapshotPolicyDaoMock).findOneByVolumeInterval(Mockito.anyLong(), Mockito.eq(intervalType));
Mockito.doNothing().when(_snapshotMgr).updateSnapshotPolicy(Mockito.any(SnapshotPolicyVO.class), Mockito.anyString(), Mockito.anyString(),
Mockito.any(DateUtil.IntervalType.class), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean());
Mockito.doNothing().when(_snapshotMgr).createTagsForSnapshotPolicy(mapStringStringMock, snapshotPolicyVoMock);
for (IntervalType intervalType : listIntervalTypes) {
Mockito.doReturn(snapshotPolicyVoInstance).when(snapshotPolicyDaoMock).findOneByVolumeInterval(anyLong(), Mockito.eq(intervalType));
Mockito.doNothing().when(_snapshotMgr).updateSnapshotPolicy(any(SnapshotPolicyVO.class), Mockito.anyString(), Mockito.anyString(),
any(DateUtil.IntervalType.class), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean());
SnapshotPolicyVO result = _snapshotMgr.persistSnapshotPolicy(volumeMock, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, intervalType,
TEST_SNAPSHOT_POLICY_MAX_SNAPS, TEST_SNAPSHOT_POLICY_DISPLAY, TEST_SNAPSHOT_POLICY_ACTIVE, null);
SnapshotPolicyVO result = _snapshotMgr.persistSnapshotPolicy(volumeMock, TEST_SNAPSHOT_POLICY_SCHEDULE, TEST_SNAPSHOT_POLICY_TIMEZONE, intervalType,
TEST_SNAPSHOT_POLICY_MAX_SNAPS, TEST_SNAPSHOT_POLICY_DISPLAY, TEST_SNAPSHOT_POLICY_ACTIVE, null);
assertSnapshotPolicyResultAgainstPreBuiltInstance(result);
assertSnapshotPolicyResultAgainstPreBuiltInstance(result);
}
VerificationMode timesVerification = Mockito.times(listIntervalTypes.size());
Mockito.verify(_snapshotMgr, Mockito.never()).createSnapshotPolicy(anyLong(), Mockito.anyString(), Mockito.anyString(), any(DateUtil.IntervalType.class),
Mockito.anyInt(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, timesVerification).updateSnapshotPolicy(any(SnapshotPolicyVO.class), Mockito.anyString(), Mockito.anyString(),
any(DateUtil.IntervalType.class), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, timesVerification).createTagsForSnapshotPolicy(any(), any());
}
VerificationMode timesVerification = Mockito.times(listIntervalTypes.size());
Mockito.verify(_snapshotMgr, Mockito.never()).createSnapshotPolicy(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.any(DateUtil.IntervalType.class),
Mockito.anyInt(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, timesVerification).updateSnapshotPolicy(Mockito.any(SnapshotPolicyVO.class), Mockito.anyString(), Mockito.anyString(),
Mockito.any(DateUtil.IntervalType.class), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean());
Mockito.verify(_snapshotMgr, timesVerification).createTagsForSnapshotPolicy(Mockito.any(), Mockito.any());
}
private void mockForBackupSnapshotToSecondaryZoneTest(final Boolean configValue, final DataCenter.Type dcType) {

1
server/src/test/java/com/cloud/storage/snapshot/SnapshotSchedulerImplTest.java
View File

@ -34,6 +34,7 @@ import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Date;
@RunWith(MockitoJUnitRunner.class)

22
server/src/test/java/com/cloud/tags/TaggedResourceManagerImplTest.java
View File

@ -19,12 +19,11 @@
package com.cloud.tags;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.server.ResourceTag;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import junit.framework.TestCase;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
import org.junit.Assert;
import org.junit.Test;
@ -35,12 +34,11 @@ import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.server.ResourceTag;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RunWith(MockitoJUnitRunner.class)
public class TaggedResourceManagerImplTest extends TestCase {

110
server/src/test/java/com/cloud/template/HypervisorTemplateAdapterTest.java
View File

@ -18,52 +18,6 @@
package com.cloud.template;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyLong;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateDataFactory;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateInfo;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateService;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateService.TemplateApiResult;
import org.apache.cloudstack.framework.async.AsyncCallFuture;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.events.Event;
import org.apache.cloudstack.framework.events.EventBus;
import org.apache.cloudstack.framework.events.EventBusException;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO;
import org.apache.cloudstack.storage.image.datastore.ImageStoreEntity;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventUtils;
@ -79,9 +33,53 @@ import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.component.ComponentContext;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateDataFactory;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateInfo;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateService;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateService.TemplateApiResult;
import org.apache.cloudstack.framework.async.AsyncCallFuture;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.events.Event;
import org.apache.cloudstack.framework.events.EventBus;
import org.apache.cloudstack.framework.events.EventBusException;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO;
import org.apache.cloudstack.storage.image.datastore.ImageStoreEntity;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ComponentContext.class)
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyLong;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class HypervisorTemplateAdapterTest {
@Mock
EventBus _bus;
@ -130,9 +128,21 @@ public class HypervisorTemplateAdapterTest {
private Map<String, Object> oldFields = new HashMap<>();
private List<UsageEventVO> usageEvents = new ArrayList<>();
private MockedStatic<ComponentContext> componentContextMocked;
private AutoCloseable closeable;
@Before
public void before() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
}
@After
public void tearDown() throws Exception {
if (componentContextMocked != null) {
componentContextMocked.close();
}
closeable.close();
}
public UsageEventUtils setupUsageUtils() throws EventBusException {
@ -155,7 +165,7 @@ public class HypervisorTemplateAdapterTest {
}
}).when(_bus).publish(any(Event.class));
PowerMockito.mockStatic(ComponentContext.class);
componentContextMocked = Mockito.mockStatic(ComponentContext.class);
when(ComponentContext.getComponent(eq(EventBus.class))).thenReturn(_bus);
UsageEventUtils utils = new UsageEventUtils();

12
server/src/test/java/com/cloud/template/TemplateManagerImplTest.java
View File

@ -31,15 +31,15 @@ import com.cloud.host.Status;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor;
import com.cloud.hypervisor.HypervisorGuruManager;
import com.cloud.storage.Storage;
import com.cloud.storage.TemplateProfile;
import com.cloud.projects.ProjectManager;
import com.cloud.storage.GuestOSVO;
import com.cloud.storage.Snapshot;
import com.cloud.storage.SnapshotVO;
import com.cloud.storage.Storage;
import com.cloud.storage.StorageManager;
import com.cloud.storage.StoragePool;
import com.cloud.storage.StoragePoolStatus;
import com.cloud.storage.TemplateProfile;
import com.cloud.storage.VMTemplateStoragePoolVO;
import com.cloud.storage.VMTemplateStorageResourceAssoc;
import com.cloud.storage.VMTemplateVO;
@ -75,6 +75,7 @@ import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.engine.subsystem.api.storage.EndPointSelector;
import org.apache.cloudstack.engine.subsystem.api.storage.PrimaryDataStore;
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotDataFactory;
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotService;
import org.apache.cloudstack.engine.subsystem.api.storage.StorageCacheManager;
import org.apache.cloudstack.engine.subsystem.api.storage.StorageStrategyFactory;
import org.apache.cloudstack.engine.subsystem.api.storage.TemplateDataFactory;
@ -82,6 +83,7 @@ import org.apache.cloudstack.engine.subsystem.api.storage.TemplateService;
import org.apache.cloudstack.engine.subsystem.api.storage.VolumeDataFactory;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.snapshot.SnapshotHelper;
import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
@ -98,7 +100,6 @@ import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ -122,8 +123,6 @@ import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotService;
import org.apache.cloudstack.snapshot.SnapshotHelper;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.nullable;
@ -131,12 +130,11 @@ import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.eq;
@RunWith(SpringJUnit4ClassRunner.class)
@PrepareForTest(CallContext.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
public class TemplateManagerImplTest {

54
server/src/test/java/com/cloud/user/AccountManagerImplTest.java
View File

@ -16,33 +16,6 @@
// under the License.
package com.cloud.user;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.command.admin.user.GetUserKeysCmd;
import org.apache.cloudstack.api.command.admin.user.UpdateUserCmd;
import org.apache.cloudstack.api.response.UserTwoFactorAuthenticationSetupResponse;
import org.apache.cloudstack.auth.UserAuthenticator;
import org.apache.cloudstack.auth.UserAuthenticator.ActionOnFailedAuthentication;
import org.apache.cloudstack.auth.UserTwoFactorAuthenticator;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.ArgumentMatchers.nullable;
import com.cloud.acl.DomainChecker;
import com.cloud.api.auth.SetupUserTwoFactorAuthenticationCmd;
import com.cloud.domain.Domain;
@ -60,6 +33,33 @@ import com.cloud.vm.UserVmManagerImpl;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.snapshot.VMSnapshotVO;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.command.admin.user.GetUserKeysCmd;
import org.apache.cloudstack.api.command.admin.user.UpdateUserCmd;
import org.apache.cloudstack.api.response.UserTwoFactorAuthenticationSetupResponse;
import org.apache.cloudstack.auth.UserAuthenticator;
import org.apache.cloudstack.auth.UserAuthenticator.ActionOnFailedAuthentication;
import org.apache.cloudstack.auth.UserTwoFactorAuthenticator;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.mockito.ArgumentMatchers.nullable;
@RunWith(MockitoJUnitRunner.class)
public class AccountManagerImplTest extends AccountManagetImplTestBase {

59
server/src/test/java/com/cloud/user/AccountManagerImplVolumeDeleteEventTest.java
View File

@ -16,36 +16,6 @@
// under the License.
package com.cloud.user;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.engine.cloud.entity.api.VirtualMachineEntity;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.domain.DomainVO;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventUtils;
@ -61,6 +31,35 @@ import com.cloud.vm.UserVmManagerImpl;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.dao.VmStatsDao;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.engine.cloud.entity.api.VirtualMachineEntity;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class AccountManagerImplVolumeDeleteEventTest extends AccountManagetImplTestBase {

47
server/src/test/java/com/cloud/user/AccountManagetImplTestBase.java
View File

@ -16,30 +16,6 @@
// under the License.
package com.cloud.user;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.apache.cloudstack.acl.SecurityChecker;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.auth.UserAuthenticator;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.engine.service.api.OrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.region.gslb.GlobalLoadBalancerRuleDao;
import org.apache.cloudstack.resourcedetail.dao.UserDetailsDao;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.configuration.dao.ResourceCountDao;
import com.cloud.configuration.dao.ResourceLimitDao;
@ -81,6 +57,29 @@ import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.cloud.vm.snapshot.VMSnapshotManager;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
import org.apache.cloudstack.acl.SecurityChecker;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.auth.UserAuthenticator;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.engine.service.api.OrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.region.gslb.GlobalLoadBalancerRuleDao;
import org.apache.cloudstack.resourcedetail.dao.UserDetailsDao;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
@RunWith(MockitoJUnitRunner.class)
public class AccountManagetImplTestBase {

100
server/src/test/java/com/cloud/user/DomainManagerImplTest.java
View File

@ -17,16 +17,32 @@
package com.cloud.user;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import com.cloud.api.query.dao.DiskOfferingJoinDao;
import com.cloud.api.query.dao.NetworkOfferingJoinDao;
import com.cloud.api.query.dao.ServiceOfferingJoinDao;
import com.cloud.api.query.dao.VpcOfferingJoinDao;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.configuration.Resource.ResourceOwnerType;
import com.cloud.configuration.ResourceLimit;
import com.cloud.configuration.dao.ResourceCountDao;
import com.cloud.configuration.dao.ResourceLimitDao;
import com.cloud.dc.DedicatedResourceVO;
import com.cloud.dc.dao.DedicatedResourceDao;
import com.cloud.domain.Domain;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import com.cloud.domain.dao.DomainDetailsDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.network.dao.NetworkDomainDao;
import com.cloud.projects.ProjectManager;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.UuidUtils;
import com.cloud.utils.db.Filter;
import com.cloud.utils.db.GlobalLock;
import com.cloud.utils.db.SearchCriteria;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.net.NetUtils;
import org.apache.cloudstack.annotation.dao.AnnotationDao;
import org.apache.cloudstack.context.CallContext;
@ -41,37 +57,18 @@ import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.api.query.dao.DiskOfferingJoinDao;
import com.cloud.api.query.dao.ServiceOfferingJoinDao;
import com.cloud.configuration.ConfigurationManager;
import com.cloud.configuration.Resource.ResourceOwnerType;
import com.cloud.configuration.dao.ResourceCountDao;
import com.cloud.configuration.dao.ResourceLimitDao;
import com.cloud.dc.DedicatedResourceVO;
import com.cloud.dc.dao.DedicatedResourceDao;
import com.cloud.domain.Domain;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.PermissionDeniedException;
import com.cloud.network.dao.NetworkDomainDao;
import com.cloud.projects.ProjectManager;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.db.Filter;
import com.cloud.utils.db.GlobalLock;
import com.cloud.utils.db.SearchCriteria;
import com.cloud.utils.exception.CloudRuntimeException;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
@PowerMockIgnore("javax.management.*")
@RunWith(PowerMockRunner.class)
@RunWith(MockitoJUnitRunner.class)
public class DomainManagerImplTest {
@Mock
DomainDao domainDaoMock;
@ -317,13 +314,13 @@ public class DomainManagerImplTest {
}
@Test
@PrepareForTest(NetUtils.class)
public void validateNetworkDomainTestNullNetworkDomainDoesNotCallVerifyDomainName() {
PowerMockito.mockStatic(NetUtils.class);
PowerMockito.when(NetUtils.verifyDomainName(Mockito.anyString())).thenReturn(true);
domainManager.validateNetworkDomain(null);
PowerMockito.verifyStatic(NetUtils.class, Mockito.never());
NetUtils.verifyDomainName(Mockito.anyString());
try (MockedStatic<NetUtils> ignored = Mockito.mockStatic(NetUtils.class)) {
Mockito.when(NetUtils.verifyDomainName(Mockito.anyString())).thenReturn(true);
domainManager.validateNetworkDomain(null);
Mockito.verify(NetUtils.class, Mockito.never());
NetUtils.verifyDomainName(Mockito.anyString());
}
}
@Test (expected = InvalidParameterValueException.class)
@ -386,29 +383,28 @@ public class DomainManagerImplTest {
}
@Test
@PrepareForTest(CallContext.class)
public void createDomainTest(){
Mockito.doNothing().when(domainManager).validateDomainNameAndNetworkDomain(Mockito.any(String.class), Mockito.any(Long.class), Mockito.any(String.class));
DomainVO domainVoMock = Mockito.mock(DomainVO.class);
Mockito.doReturn(domainVoMock).when(domainManager).createDomainVo("test",1L,2L,"netTest","uuidTest");
Mockito.doReturn(domainVoMock).when(domainDaoMock).create(domainVoMock);
PowerMockito.mockStatic(CallContext.class);
CallContext callContextMock = Mockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
try (MockedStatic<CallContext> ignored = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = Mockito.mock(CallContext.class);
Mockito.when(CallContext.current()).thenReturn(callContextMock);
Domain actualDomain = domainManager.createDomain("test",1L,2L,"netTest","uuidTest");
Domain actualDomain = domainManager.createDomain("test", 1L, 2L, "netTest", "uuidTest");
Mockito.verify(domainManager).validateDomainNameAndNetworkDomain("test", 1L, "netTest");
Mockito.verify(domainManager).createDomainVo("test",1L,2L,"netTest","uuidTest");
Mockito.verify(domainManager).validateDomainNameAndNetworkDomain("test", 1L, "netTest");
Mockito.verify(domainManager).createDomainVo("test", 1L, 2L, "netTest", "uuidTest");
Mockito.verify(domainDaoMock).create(domainVoMock);
Mockito.verify(_resourceCountDao).createResourceCounts(domainVoMock.getId(), ResourceLimit.ResourceOwnerType.Domain);
PowerMockito.verifyStatic(CallContext.class);
CallContext.current();
Mockito.verify(callContextMock).putContextParameter(Domain.class, domainVoMock.getUuid());
Mockito.verify(_messageBus).publish("DomainManagerImpl", DomainManager.MESSAGE_ADD_DOMAIN_EVENT, PublishScope.LOCAL, domainVoMock.getId());
Assert.assertEquals(domainVoMock, actualDomain);
Mockito.verify(domainDaoMock).create(domainVoMock);
Mockito.verify(_resourceCountDao).createResourceCounts(domainVoMock.getId(), ResourceLimit.ResourceOwnerType.Domain);
CallContext.current();
Mockito.verify(callContextMock).putContextParameter(Domain.class, domainVoMock.getUuid());
Mockito.verify(_messageBus).publish("DomainManagerImpl", DomainManager.MESSAGE_ADD_DOMAIN_EVENT, PublishScope.LOCAL, domainVoMock.getId());
Assert.assertEquals(domainVoMock, actualDomain);
}
}
}

41
server/src/test/java/com/cloud/user/MockAccountManagerImpl.java
View File

@ -16,29 +16,7 @@
// under the License.
package com.cloud.user;
import java.util.List;
import java.util.Map;
import java.net.InetAddress;
import javax.naming.ConfigurationException;
import com.cloud.api.auth.SetupUserTwoFactorAuthenticationCmd;
import org.apache.cloudstack.api.command.admin.account.CreateAccountCmd;
import org.apache.cloudstack.api.command.admin.user.GetUserKeysCmd;
import org.apache.cloudstack.api.command.admin.user.MoveUserCmd;
import org.apache.cloudstack.api.response.UserTwoFactorAuthenticationSetupResponse;
import org.apache.cloudstack.auth.UserTwoFactorAuthenticator;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.springframework.stereotype.Component;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.RoleType;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.command.admin.account.UpdateAccountCmd;
import org.apache.cloudstack.api.command.admin.user.DeleteUserCmd;
import org.apache.cloudstack.api.command.admin.user.RegisterCmd;
import org.apache.cloudstack.api.command.admin.user.UpdateUserCmd;
import com.cloud.api.query.vo.ControlledViewEntity;
import com.cloud.dc.DataCenter;
import com.cloud.domain.Domain;
@ -56,6 +34,25 @@ import com.cloud.utils.component.Manager;
import com.cloud.utils.component.ManagerBase;
import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.RoleType;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
import org.apache.cloudstack.api.command.admin.account.CreateAccountCmd;
import org.apache.cloudstack.api.command.admin.account.UpdateAccountCmd;
import org.apache.cloudstack.api.command.admin.user.DeleteUserCmd;
import org.apache.cloudstack.api.command.admin.user.GetUserKeysCmd;
import org.apache.cloudstack.api.command.admin.user.MoveUserCmd;
import org.apache.cloudstack.api.command.admin.user.RegisterCmd;
import org.apache.cloudstack.api.command.admin.user.UpdateUserCmd;
import org.apache.cloudstack.api.response.UserTwoFactorAuthenticationSetupResponse;
import org.apache.cloudstack.auth.UserTwoFactorAuthenticator;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.springframework.stereotype.Component;
import javax.naming.ConfigurationException;
import java.net.InetAddress;
import java.util.List;
import java.util.Map;
@Component
public class MockAccountManagerImpl extends ManagerBase implements Manager, AccountManager {

13
server/src/test/java/com/cloud/user/MockUsageEventDao.java
View File

@ -16,13 +16,6 @@
// under the License.
package com.cloud.user;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import javax.naming.ConfigurationException;
import com.cloud.event.UsageEventVO;
import com.cloud.event.dao.UsageEventDao;
import com.cloud.utils.Pair;
@ -32,6 +25,12 @@ import com.cloud.utils.db.GenericSearchBuilder;
import com.cloud.utils.db.SearchBuilder;
import com.cloud.utils.db.SearchCriteria;
import javax.naming.ConfigurationException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
public class MockUsageEventDao implements UsageEventDao{
List<UsageEventVO> persistedItems;

Some files were not shown because too many files have changed in this diff Show More