apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove powermock from network elements (#7791)

Browse Source
This commit is contained in:
Vishesh 2023-08-07 12:54:26 +05:30 committed by GitHub
parent 0318e9fccb
commit 55f0801b18
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
63 changed files with 1158 additions and 904 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
plugins/network-elements/elastic-loadbalancer/src/test/java/com/cloud/network/lb/ElasticLoadBalancerManagerImplTest.java
View File

@ -25,14 +25,14 @@ import static org.mockito.Mockito.when;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.runners.MockitoJUnitRunner;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import com.cloud.agent.api.check.CheckSshAnswer;
import com.cloud.agent.manager.Commands;
import com.cloud.network.lb.dao.ElasticLbVmMapDao;
import com.cloud.vm.ReservationContext;
import com.cloud.vm.VirtualMachineProfile;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class ElasticLoadBalancerManagerImplTest {
@ -90,7 +90,7 @@ public class ElasticLoadBalancerManagerImplTest {
public void testGarbageCollectUnusedElbVmsWhenVariableUnusedElbVmsIsNull() throws Exception {
ElasticLbVmMapDao elasticLbVmMapDaoMock = mock(ElasticLbVmMapDao.class);
when(elasticLbVmMapDaoMock.listUnusedElbVms()).thenReturn(null);
Whitebox.setInternalState(elasticLoadBalancerManagerImpl, "_elbVmMapDao", elasticLbVmMapDaoMock);
ReflectionTestUtils.setField(elasticLoadBalancerManagerImpl, "_elbVmMapDao", elasticLbVmMapDaoMock);
try {
elasticLoadBalancerManagerImpl.garbageCollectUnusedElbVms();

12
plugins/network-elements/elastic-loadbalancer/src/test/java/com/cloud/network/lb/LoadBalanceRuleHandlerTest.java
View File

@ -36,8 +36,6 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.powermock.reflect.Whitebox;
import com.cloud.dc.PodVlanMapVO;
import com.cloud.dc.dao.PodVlanMapDao;
@ -47,6 +45,8 @@ import com.cloud.vm.DomainRouterVO;
import com.cloud.vm.VirtualMachineManager;
import com.cloud.vm.VirtualMachineProfile.Param;
import com.cloud.vm.dao.DomainRouterDao;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class LoadBalanceRuleHandlerTest {
@ -68,10 +68,10 @@ public class LoadBalanceRuleHandlerTest {
@Before
public void setup() {
Whitebox.setInternalState(loadBalanceRuleHandler, "_itMgr", virtualMachineManagerMock);
Whitebox.setInternalState(loadBalanceRuleHandler, "_routerDao", domainRouterDaoMock);
Whitebox.setInternalState(loadBalanceRuleHandler, "_elbVmMapDao", elasticLbVmMapDao);
Whitebox.setInternalState(loadBalanceRuleHandler, "_podVlanMapDao", podVlanMapDao);
ReflectionTestUtils.setField(loadBalanceRuleHandler, "_itMgr", virtualMachineManagerMock);
ReflectionTestUtils.setField(loadBalanceRuleHandler, "_routerDao", domainRouterDaoMock);
ReflectionTestUtils.setField(loadBalanceRuleHandler, "_elbVmMapDao", elasticLbVmMapDao);
ReflectionTestUtils.setField(loadBalanceRuleHandler, "_podVlanMapDao", podVlanMapDao);
}
@Test

1
plugins/network-elements/elastic-loadbalancer/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker Normal file
View File

@ -0,0 +1 @@
mock-maker-inline

21
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/AddTungstenFabricNetworkGatewayToLogicalRouterCmdTest.java
View File

@ -24,17 +24,21 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.List;
@RunWith(MockitoJUnitRunner.class)
public class AddTungstenFabricNetworkGatewayToLogicalRouterCmdTest {
@Mock
@ -42,18 +46,25 @@ public class AddTungstenFabricNetworkGatewayToLogicalRouterCmdTest {
AddTungstenFabricNetworkGatewayToLogicalRouterCmd addTungstenFabricNetworkGatewayToLogicalRouterCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
addTungstenFabricNetworkGatewayToLogicalRouterCmd = new AddTungstenFabricNetworkGatewayToLogicalRouterCmd();
addTungstenFabricNetworkGatewayToLogicalRouterCmd.tungstenService = tungstenService;
Whitebox.setInternalState(addTungstenFabricNetworkGatewayToLogicalRouterCmd, "zoneId", 1L);
Whitebox.setInternalState(addTungstenFabricNetworkGatewayToLogicalRouterCmd, "networkUuid", "005f0dea-0196" +
ReflectionTestUtils.setField(addTungstenFabricNetworkGatewayToLogicalRouterCmd, "zoneId", 1L);
ReflectionTestUtils.setField(addTungstenFabricNetworkGatewayToLogicalRouterCmd, "networkUuid", "005f0dea-0196" +
"-11ec-a1ed-b42e99f6e187");
Whitebox.setInternalState(addTungstenFabricNetworkGatewayToLogicalRouterCmd, "logicalRouterUuid", "125f0dea" +
ReflectionTestUtils.setField(addTungstenFabricNetworkGatewayToLogicalRouterCmd, "logicalRouterUuid", "125f0dea" +
"-0196-11ec-a1ed-b42e99f6e187");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException,
ConcurrentOperationException, ResourceAllocationException, NetworkRuleConflictException {

43
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/AddTungstenFabricPolicyRuleCmdTest.java
View File

@ -27,12 +27,15 @@ import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class AddTungstenFabricPolicyRuleCmdTest {
@Mock
@ -40,26 +43,32 @@ public class AddTungstenFabricPolicyRuleCmdTest {
AddTungstenFabricPolicyRuleCmd addTungstenFabricPolicyRuleCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
addTungstenFabricPolicyRuleCmd = new AddTungstenFabricPolicyRuleCmd();
addTungstenFabricPolicyRuleCmd.tungstenService = tungstenService;
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "zoneId", 1L);
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "policyUuid", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "action", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "direction", "oneway");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "protocol", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "srcNetwork", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "srcIpPrefix", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "srcIpPrefixLen", 1);
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "srcStartPort", 1);
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "srcEndPort", 1);
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "destNetwork", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "destIpPrefix", "test");
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "destIpPrefixLen", 1);
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "destStartPort", 1);
Whitebox.setInternalState(addTungstenFabricPolicyRuleCmd, "destEndPort", 1);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "zoneId", 1L);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "policyUuid", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "action", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "direction", "oneway");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "protocol", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "srcNetwork", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "srcIpPrefix", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "srcIpPrefixLen", 1);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "srcStartPort", 1);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "srcEndPort", 1);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "destNetwork", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "destIpPrefix", "test");
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "destIpPrefixLen", 1);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "destStartPort", 1);
ReflectionTestUtils.setField(addTungstenFabricPolicyRuleCmd, "destEndPort", 1);
}
public void tearDown() throws Exception {
closeable.close();
}
@Test

25
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ApplyTungstenFabricPolicyCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricPolicyResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class ApplyTungstenFabricPolicyCmdTest {
@Mock
@ -40,16 +44,23 @@ public class ApplyTungstenFabricPolicyCmdTest {
ApplyTungstenFabricPolicyCmd applyTungstenFabricPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
applyTungstenFabricPolicyCmd = new ApplyTungstenFabricPolicyCmd();
applyTungstenFabricPolicyCmd.tungstenService = tungstenService;
Whitebox.setInternalState(applyTungstenFabricPolicyCmd, "zoneId", 1L);
Whitebox.setInternalState(applyTungstenFabricPolicyCmd, "networkUuid", "test");
Whitebox.setInternalState(applyTungstenFabricPolicyCmd, "policyUuid", "test");
Whitebox.setInternalState(applyTungstenFabricPolicyCmd, "majorSequence", 1);
Whitebox.setInternalState(applyTungstenFabricPolicyCmd, "minorSequence", 1);
ReflectionTestUtils.setField(applyTungstenFabricPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(applyTungstenFabricPolicyCmd, "networkUuid", "test");
ReflectionTestUtils.setField(applyTungstenFabricPolicyCmd, "policyUuid", "test");
ReflectionTestUtils.setField(applyTungstenFabricPolicyCmd, "majorSequence", 1);
ReflectionTestUtils.setField(applyTungstenFabricPolicyCmd, "minorSequence", 1);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

29
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ApplyTungstenFabricTagCmdTest.java
View File

@ -24,17 +24,21 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricTagResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
@RunWith(MockitoJUnitRunner.class)
public class ApplyTungstenFabricTagCmdTest {
@Mock
@ -42,18 +46,25 @@ public class ApplyTungstenFabricTagCmdTest {
ApplyTungstenFabricTagCmd applyTungstenFabricTagCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
applyTungstenFabricTagCmd = new ApplyTungstenFabricTagCmd();
applyTungstenFabricTagCmd.tungstenService = tungstenService;
Whitebox.setInternalState(applyTungstenFabricTagCmd, "zoneId", 1L);
Whitebox.setInternalState(applyTungstenFabricTagCmd, "networkUuids", Arrays.asList("test"));
Whitebox.setInternalState(applyTungstenFabricTagCmd, "vmUuids", Arrays.asList("test"));
Whitebox.setInternalState(applyTungstenFabricTagCmd, "nicUuids", Arrays.asList("test"));
Whitebox.setInternalState(applyTungstenFabricTagCmd, "policyUuid", "test");
Whitebox.setInternalState(applyTungstenFabricTagCmd, "applicationPolicySetUuid", "test");
Whitebox.setInternalState(applyTungstenFabricTagCmd, "tagUuid", "test");
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "zoneId", 1L);
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "networkUuids", Arrays.asList("test"));
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "vmUuids", Arrays.asList("test"));
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "nicUuids", Arrays.asList("test"));
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "policyUuid", "test");
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(applyTungstenFabricTagCmd, "tagUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

38
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ConfigTungstenFabricServiceCmdTest.java
View File

@ -28,27 +28,25 @@ import com.cloud.utils.db.EntityManager;
import com.cloud.utils.db.Transaction;
import com.cloud.utils.db.TransactionCallbackNoReturn;
import org.apache.cloudstack.api.response.SuccessResponse;
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.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
import static org.mockito.ArgumentMatchers.any;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
@RunWith(PowerMockRunner.class)
@PrepareForTest({Transaction.class, ConfigTungstenFabricServiceCmd.class})
@RunWith(MockitoJUnitRunner.class)
public class ConfigTungstenFabricServiceCmdTest {
@Mock
EntityManager entityManager;
@ -65,9 +63,10 @@ public class ConfigTungstenFabricServiceCmdTest {
ConfigTungstenFabricServiceCmd configTungstenFabricServiceCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
configTungstenFabricServiceCmd = new ConfigTungstenFabricServiceCmd();
configTungstenFabricServiceCmd._entityMgr = entityManager;
configTungstenFabricServiceCmd.networkModel = networkModel;
@ -75,8 +74,13 @@ public class ConfigTungstenFabricServiceCmdTest {
configTungstenFabricServiceCmd.networkOfferingServiceMapDao = networkOfferingServiceMapDao;
configTungstenFabricServiceCmd.networkServiceMapDao = networkServiceMapDao;
configTungstenFabricServiceCmd.physicalNetworkServiceProviderDao = physicalNetworkServiceProviderDao;
Whitebox.setInternalState(configTungstenFabricServiceCmd, "zoneId", 1L);
Whitebox.setInternalState(configTungstenFabricServiceCmd, "physicalNetworkId", 1L);
ReflectionTestUtils.setField(configTungstenFabricServiceCmd, "zoneId", 1L);
ReflectionTestUtils.setField(configTungstenFabricServiceCmd, "physicalNetworkId", 1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
@ -86,16 +90,14 @@ public class ConfigTungstenFabricServiceCmdTest {
Network managementNetwork = Mockito.mock(Network.class);
TransactionCallbackNoReturn transactionCallbackNoReturn = Mockito.mock(TransactionCallbackNoReturn.class);
List<NetworkOfferingVO> systemNetworkOffering = Arrays.asList(Mockito.mock(NetworkOfferingVO.class));
mockStatic(Transaction.class);
Mockito.when(entityManager.findById(ArgumentMatchers.any(), ArgumentMatchers.anyLong())).thenReturn(dataCenter);
Mockito.when(dataCenter.isSecurityGroupEnabled()).thenReturn(true);
Mockito.when(networkModel.getSystemNetworkByZoneAndTrafficType(ArgumentMatchers.anyLong(),
ArgumentMatchers.any())).thenReturn(managementNetwork);
Mockito.when(networkOfferingDao.listSystemNetworkOfferings()).thenReturn(systemNetworkOffering);
PowerMockito.when(Transaction.execute(any(TransactionCallbackNoReturn.class))).thenReturn(transactionCallbackNoReturn);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
configTungstenFabricServiceCmd.execute();
Assert.assertEquals(successResponse, configTungstenFabricServiceCmd.getResponseObject());
try (MockedStatic<Transaction> transactionMocked = Mockito.mockStatic(Transaction.class)) {
transactionMocked.when(() -> Transaction.execute(any(TransactionCallbackNoReturn.class))).thenReturn(transactionCallbackNoReturn);
configTungstenFabricServiceCmd.execute();
SuccessResponse response = (SuccessResponse) configTungstenFabricServiceCmd.getResponseObject();
Assert.assertTrue(response.getSuccess());
}
}
}

23
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricAddressGroupCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricAddressGroupResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricAddressGroupCmdTest {
@Mock
@ -40,15 +44,22 @@ public class CreateTungstenFabricAddressGroupCmdTest {
CreateTungstenFabricAddressGroupCmd createTungstenFabricAddressGroupCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricAddressGroupCmd = new CreateTungstenFabricAddressGroupCmd();
createTungstenFabricAddressGroupCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricAddressGroupCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricAddressGroupCmd, "name", "test");
Whitebox.setInternalState(createTungstenFabricAddressGroupCmd, "ipPrefix", "test");
Whitebox.setInternalState(createTungstenFabricAddressGroupCmd, "ipPrefixLen", 1);
ReflectionTestUtils.setField(createTungstenFabricAddressGroupCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricAddressGroupCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricAddressGroupCmd, "ipPrefix", "test");
ReflectionTestUtils.setField(createTungstenFabricAddressGroupCmd, "ipPrefixLen", 1);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

19
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricApplicationPolicySetCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricApplicationPolicySetResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricApplicationPolicySetCmdTest {
@Mock
@ -40,13 +44,20 @@ public class CreateTungstenFabricApplicationPolicySetCmdTest {
CreateTungstenFabricApplicationPolicySetCmd createTungstenFabricApplicationPolicySetCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricApplicationPolicySetCmd = new CreateTungstenFabricApplicationPolicySetCmd();
createTungstenFabricApplicationPolicySetCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricApplicationPolicySetCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricApplicationPolicySetCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricApplicationPolicySetCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricApplicationPolicySetCmd, "name", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

23
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricFirewallPolicyCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricFirewallPolicyResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricFirewallPolicyCmdTest {
@Mock
@ -40,15 +44,22 @@ public class CreateTungstenFabricFirewallPolicyCmdTest {
CreateTungstenFabricFirewallPolicyCmd createTungstenFabricFirewallPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricFirewallPolicyCmd = new CreateTungstenFabricFirewallPolicyCmd();
createTungstenFabricFirewallPolicyCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricFirewallPolicyCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricFirewallPolicyCmd, "applicationPolicySetUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallPolicyCmd, "name", "test");
Whitebox.setInternalState(createTungstenFabricFirewallPolicyCmd, "sequence", 1);
ReflectionTestUtils.setField(createTungstenFabricFirewallPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricFirewallPolicyCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallPolicyCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallPolicyCmd, "sequence", 1);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

41
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricFirewallRuleCmdTest.java
View File

@ -27,12 +27,15 @@ import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricFirewallRuleCmdTest {
@Mock
@ -40,25 +43,31 @@ public class CreateTungstenFabricFirewallRuleCmdTest {
CreateTungstenFabricFirewallRuleCmd createTungstenFabricFirewallRuleCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricFirewallRuleCmd = new CreateTungstenFabricFirewallRuleCmd();
createTungstenFabricFirewallRuleCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "firewallPolicyUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "name", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "action", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "serviceGroupUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "srcTagUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "srcAddressGroupUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "srcNetworkUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "direction", "oneway");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "destTagUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "destAddressGroupUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "destNetworkUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "tagTypeUuid", "test");
Whitebox.setInternalState(createTungstenFabricFirewallRuleCmd, "sequence", 1);
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "firewallPolicyUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "action", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "serviceGroupUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "srcTagUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "srcAddressGroupUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "srcNetworkUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "direction", "oneway");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "destTagUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "destAddressGroupUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "destNetworkUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "tagTypeUuid", "test");
ReflectionTestUtils.setField(createTungstenFabricFirewallRuleCmd, "sequence", 1);
}
public void tearDown() throws Exception {
closeable.close();
}
@Test

19
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricLogicalRouterCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricLogicalRouterCmdTest {
@Mock
@ -40,13 +44,20 @@ public class CreateTungstenFabricLogicalRouterCmdTest {
CreateTungstenFabricLogicalRouterCmd createTungstenFabricLogicalRouterCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricLogicalRouterCmd = new CreateTungstenFabricLogicalRouterCmd();
createTungstenFabricLogicalRouterCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricLogicalRouterCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricLogicalRouterCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricLogicalRouterCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricLogicalRouterCmd, "name", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

25
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricManagementNetworkCmdTest.java
View File

@ -20,6 +20,7 @@ import com.cloud.dc.HostPodVO;
import com.cloud.dc.dao.HostPodDao;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -28,13 +29,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(CreateTungstenFabricManagementNetworkCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricManagementNetworkCmdTest {
@Mock
@ -44,24 +42,29 @@ public class CreateTungstenFabricManagementNetworkCmdTest {
CreateTungstenFabricManagementNetworkCmd createTungstenFabricManagementNetworkCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricManagementNetworkCmd = new CreateTungstenFabricManagementNetworkCmd();
createTungstenFabricManagementNetworkCmd.tungstenService = tungstenService;
createTungstenFabricManagementNetworkCmd.podDao = podDao;
Whitebox.setInternalState(createTungstenFabricManagementNetworkCmd, "podId", 1L);
ReflectionTestUtils.setField(createTungstenFabricManagementNetworkCmd, "podId", 1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
HostPodVO pod = Mockito.mock(HostPodVO.class);
Mockito.when(podDao.findById(ArgumentMatchers.anyLong())).thenReturn(pod);
Mockito.when(tungstenService.createManagementNetwork(ArgumentMatchers.anyLong())).thenReturn(true);
Mockito.when(tungstenService.addManagementNetworkSubnet(ArgumentMatchers.any())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
createTungstenFabricManagementNetworkCmd.execute();
Assert.assertEquals(successResponse, createTungstenFabricManagementNetworkCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse)createTungstenFabricManagementNetworkCmd.getResponseObject()).getSuccess());
}
}

19
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricPolicyCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricPolicyResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricPolicyCmdTest {
@Mock
@ -40,13 +44,20 @@ public class CreateTungstenFabricPolicyCmdTest {
CreateTungstenFabricPolicyCmd createTungstenFabricPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricPolicyCmd = new CreateTungstenFabricPolicyCmd();
createTungstenFabricPolicyCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricPolicyCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricPolicyCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricPolicyCmd, "name", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

29
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricProviderCmdTest.java
View File

@ -28,12 +28,15 @@ import org.apache.cloudstack.network.tungsten.service.TungstenProviderService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricProviderCmdTest {
@Mock
@ -41,18 +44,24 @@ public class CreateTungstenFabricProviderCmdTest {
CreateTungstenFabricProviderCmd createTungstenFabricProviderCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricProviderCmd = new CreateTungstenFabricProviderCmd();
Whitebox.setInternalState(createTungstenFabricProviderCmd, "tungstenProviderService", tungstenProviderService);
Whitebox.setInternalState(createTungstenFabricProviderCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricProviderCmd, "name", "test");
Whitebox.setInternalState(createTungstenFabricProviderCmd, "hostname", "test");
Whitebox.setInternalState(createTungstenFabricProviderCmd, "port", "test");
Whitebox.setInternalState(createTungstenFabricProviderCmd, "gateway", "test");
Whitebox.setInternalState(createTungstenFabricProviderCmd, "vrouterPort", "test");
Whitebox.setInternalState(createTungstenFabricProviderCmd, "introspectPort", "test");
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "tungstenProviderService", tungstenProviderService);
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "hostname", "test");
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "port", "test");
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "gateway", "test");
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "vrouterPort", "test");
ReflectionTestUtils.setField(createTungstenFabricProviderCmd, "introspectPort", "test");
}
public void tearDown() throws Exception {
closeable.close();
}
@Test

25
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricPublicNetworkCmdTest.java
View File

@ -23,6 +23,7 @@ import com.cloud.network.NetworkModel;
import com.cloud.utils.db.SearchCriteria;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -31,16 +32,13 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(CreateTungstenFabricPublicNetworkCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricPublicNetworkCmdTest {
@Mock
@ -52,19 +50,25 @@ public class CreateTungstenFabricPublicNetworkCmdTest {
CreateTungstenFabricPublicNetworkCmd createTungstenFabricPublicNetworkCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricPublicNetworkCmd = new CreateTungstenFabricPublicNetworkCmd();
createTungstenFabricPublicNetworkCmd.tungstenService = tungstenService;
createTungstenFabricPublicNetworkCmd.vlanDao = vlanDao;
createTungstenFabricPublicNetworkCmd.networkModel = networkModel;
Whitebox.setInternalState(createTungstenFabricPublicNetworkCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricPublicNetworkCmd, "zoneId", 1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Network publicNetwork = Mockito.mock(Network.class);
SearchCriteria<VlanVO> sc = Mockito.mock(SearchCriteria.class);
List<VlanVO> pubVlanVOList = Arrays.asList(Mockito.mock(VlanVO.class));
@ -75,8 +79,7 @@ public class CreateTungstenFabricPublicNetworkCmdTest {
Mockito.when(tungstenService.createPublicNetwork(ArgumentMatchers.anyLong())).thenReturn(true);
Mockito.when(tungstenService.addPublicNetworkSubnet(ArgumentMatchers.any())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
createTungstenFabricPublicNetworkCmd.execute();
Assert.assertEquals(successResponse, createTungstenFabricPublicNetworkCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) createTungstenFabricPublicNetworkCmd.getResponseObject()).getSuccess());
}
}

25
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricServiceGroupCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricServiceGroupResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricServiceGroupCmdTest {
@Mock
@ -40,16 +44,23 @@ public class CreateTungstenFabricServiceGroupCmdTest {
CreateTungstenFabricServiceGroupCmd createTungstenFabricServiceGroupCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricServiceGroupCmd = new CreateTungstenFabricServiceGroupCmd();
createTungstenFabricServiceGroupCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricServiceGroupCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricServiceGroupCmd, "name", "test");
Whitebox.setInternalState(createTungstenFabricServiceGroupCmd, "protocol", "test");
Whitebox.setInternalState(createTungstenFabricServiceGroupCmd, "startPort", 1);
Whitebox.setInternalState(createTungstenFabricServiceGroupCmd, "endPort", 1);
ReflectionTestUtils.setField(createTungstenFabricServiceGroupCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricServiceGroupCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricServiceGroupCmd, "protocol", "test");
ReflectionTestUtils.setField(createTungstenFabricServiceGroupCmd, "startPort", 1);
ReflectionTestUtils.setField(createTungstenFabricServiceGroupCmd, "endPort", 1);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

21
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricTagCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricTagResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricTagCmdTest {
@Mock
@ -40,14 +44,21 @@ public class CreateTungstenFabricTagCmdTest {
CreateTungstenFabricTagCmd createTungstenFabricTagCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricTagCmd = new CreateTungstenFabricTagCmd();
createTungstenFabricTagCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricTagCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricTagCmd, "tagType", "test");
Whitebox.setInternalState(createTungstenFabricTagCmd, "tagValue", "test");
ReflectionTestUtils.setField(createTungstenFabricTagCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricTagCmd, "tagType", "test");
ReflectionTestUtils.setField(createTungstenFabricTagCmd, "tagValue", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

19
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/CreateTungstenFabricTagTypeCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricTagTypeResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class CreateTungstenFabricTagTypeCmdTest {
@Mock
@ -40,13 +44,20 @@ public class CreateTungstenFabricTagTypeCmdTest {
CreateTungstenFabricTagTypeCmd createTungstenFabricTagTypeCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
createTungstenFabricTagTypeCmd = new CreateTungstenFabricTagTypeCmd();
createTungstenFabricTagTypeCmd.tungstenService = tungstenService;
Whitebox.setInternalState(createTungstenFabricTagTypeCmd, "zoneId", 1L);
Whitebox.setInternalState(createTungstenFabricTagTypeCmd, "name", "test");
ReflectionTestUtils.setField(createTungstenFabricTagTypeCmd, "zoneId", 1L);
ReflectionTestUtils.setField(createTungstenFabricTagTypeCmd, "name", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

26
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricAddressGroupCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricAddressGroupCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricAddressGroupCmdTest {
@Mock
@ -40,13 +38,20 @@ public class DeleteTungstenFabricAddressGroupCmdTest {
DeleteTungstenFabricAddressGroupCmd deleteTungstenFabricAddressGroupCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricAddressGroupCmd = new DeleteTungstenFabricAddressGroupCmd();
deleteTungstenFabricAddressGroupCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricAddressGroupCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricAddressGroupCmd, "addressGroupUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricAddressGroupCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricAddressGroupCmd, "addressGroupUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
@ -54,8 +59,7 @@ public class DeleteTungstenFabricAddressGroupCmdTest {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenAddressGroup(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricAddressGroupCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricAddressGroupCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricAddressGroupCmd.getResponseObject()).getSuccess());
}
}

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricApplicationPolicySetCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricApplicationPolicySetCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricApplicationPolicySetCmdTest {
@Mock
@ -40,22 +38,27 @@ public class DeleteTungstenFabricApplicationPolicySetCmdTest {
DeleteTungstenFabricApplicationPolicySetCmd deleteTungstenFabricApplicationPolicySetCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricApplicationPolicySetCmd = new DeleteTungstenFabricApplicationPolicySetCmd();
deleteTungstenFabricApplicationPolicySetCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricApplicationPolicySetCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricApplicationPolicySetCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricApplicationPolicySetCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricApplicationPolicySetCmd, "applicationPolicySetUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenApplicationPolicySet(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricApplicationPolicySetCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricApplicationPolicySetCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricApplicationPolicySetCmd.getResponseObject()).getSuccess());
}
}

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricFirewallPolicyCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricFirewallPolicyCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricFirewallPolicyCmdTest {
@Mock
@ -40,22 +38,27 @@ public class DeleteTungstenFabricFirewallPolicyCmdTest {
DeleteTungstenFabricFirewallPolicyCmd deleteTungstenFabricFirewallPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricFirewallPolicyCmd = new DeleteTungstenFabricFirewallPolicyCmd();
deleteTungstenFabricFirewallPolicyCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricFirewallPolicyCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricFirewallPolicyCmd, "firewallPolicyUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricFirewallPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricFirewallPolicyCmd, "firewallPolicyUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenFirewallPolicy(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricFirewallPolicyCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricFirewallPolicyCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricFirewallPolicyCmd.getResponseObject()).getSuccess());
}
}

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricFirewallRuleCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricFirewallRuleCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricFirewallRuleCmdTest {
@Mock
@ -40,22 +38,27 @@ public class DeleteTungstenFabricFirewallRuleCmdTest {
DeleteTungstenFabricFirewallRuleCmd deleteTungstenFabricFirewallRuleCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricFirewallRuleCmd = new DeleteTungstenFabricFirewallRuleCmd();
deleteTungstenFabricFirewallRuleCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricFirewallRuleCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricFirewallRuleCmd, "firewallRuleUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricFirewallRuleCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricFirewallRuleCmd, "firewallRuleUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenFirewallRule(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricFirewallRuleCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricFirewallRuleCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricFirewallRuleCmd.getResponseObject()).getSuccess());
}
}

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricLogicalRouterCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,16 +27,13 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.ArrayList;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricLogicalRouterCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricLogicalRouterCmdTest {
@Mock
@ -43,25 +41,30 @@ public class DeleteTungstenFabricLogicalRouterCmdTest {
DeleteTungstenFabricLogicalRouterCmd deleteTungstenFabricLogicalRouterCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricLogicalRouterCmd = new DeleteTungstenFabricLogicalRouterCmd();
deleteTungstenFabricLogicalRouterCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricLogicalRouterCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricLogicalRouterCmd, "logicalRouterUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricLogicalRouterCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricLogicalRouterCmd, "logicalRouterUuid", "test");
}
@After
public void close() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
List<String> networkList = new ArrayList<>();
Mockito.when(tungstenService.listConnectedNetworkFromLogicalRouter(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(networkList);
Mockito.when(tungstenService.deleteLogicalRouter(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricLogicalRouterCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricLogicalRouterCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricLogicalRouterCmd.getResponseObject()).getSuccess());
}
}

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricPolicyCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricPolicyCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricPolicyCmdTest {
@Mock
@ -40,22 +38,27 @@ public class DeleteTungstenFabricPolicyCmdTest {
DeleteTungstenFabricPolicyCmd deleteTungstenFabricPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricPolicyCmd = new DeleteTungstenFabricPolicyCmd();
deleteTungstenFabricPolicyCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricPolicyCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricPolicyCmd, "policyUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricPolicyCmd, "policyUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenPolicy(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricPolicyCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricPolicyCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricPolicyCmd.getResponseObject()).getSuccess());
}
}

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricServiceGroupCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricServiceGroupCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricServiceGroupCmdTest {
@Mock
@ -40,22 +38,27 @@ public class DeleteTungstenFabricServiceGroupCmdTest {
DeleteTungstenFabricServiceGroupCmd deleteTungstenFabricServiceGroupCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricServiceGroupCmd = new DeleteTungstenFabricServiceGroupCmd();
deleteTungstenFabricServiceGroupCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricServiceGroupCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricServiceGroupCmd, "serviceGroupUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricServiceGroupCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricServiceGroupCmd, "serviceGroupUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenServiceGroup(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricServiceGroupCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricServiceGroupCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) deleteTungstenFabricServiceGroupCmd.getResponseObject()).getSuccess());
}
}

24
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricTagCmdTest.java
View File

@ -26,13 +26,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricTagCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricTagCmdTest {
@Mock
@ -40,22 +37,25 @@ public class DeleteTungstenFabricTagCmdTest {
DeleteTungstenFabricTagCmd deleteTungstenFabricTagCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricTagCmd = new DeleteTungstenFabricTagCmd();
deleteTungstenFabricTagCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricTagCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricTagCmd, "tagUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricTagCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricTagCmd, "tagUuid", "test");
}
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenTag(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricTagCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricTagCmd.getResponseObject());
Assert.assertEquals(true, ((SuccessResponse) deleteTungstenFabricTagCmd.getResponseObject()).getSuccess());
}
}

26
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/DeleteTungstenFabricTagTypeCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DeleteTungstenFabricTagTypeCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class DeleteTungstenFabricTagTypeCmdTest {
@Mock
@ -40,13 +38,20 @@ public class DeleteTungstenFabricTagTypeCmdTest {
DeleteTungstenFabricTagTypeCmd deleteTungstenFabricTagTypeCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
deleteTungstenFabricTagTypeCmd = new DeleteTungstenFabricTagTypeCmd();
deleteTungstenFabricTagTypeCmd.tungstenService = tungstenService;
Whitebox.setInternalState(deleteTungstenFabricTagTypeCmd, "zoneId", 1L);
Whitebox.setInternalState(deleteTungstenFabricTagTypeCmd, "tagTypeUuid", "test");
ReflectionTestUtils.setField(deleteTungstenFabricTagTypeCmd, "zoneId", 1L);
ReflectionTestUtils.setField(deleteTungstenFabricTagTypeCmd, "tagTypeUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
@ -54,8 +59,7 @@ public class DeleteTungstenFabricTagTypeCmdTest {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.deleteTungstenTagType(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
deleteTungstenFabricTagTypeCmd.execute();
Assert.assertEquals(successResponse, deleteTungstenFabricTagTypeCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse)deleteTungstenFabricTagTypeCmd.getResponseObject()).getSuccess());
}
}

39
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/GetLoadBalancerSslCertificateCmdTest.java
View File

@ -19,6 +19,8 @@ package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.network.lb.LoadBalancingRule;
import com.cloud.network.lb.LoadBalancingRulesManager;
import org.apache.cloudstack.network.tungsten.api.response.TlsDataResponse;
import org.apache.commons.codec.binary.Base64;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -27,13 +29,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(GetLoadBalancerSslCertificateCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class GetLoadBalancerSslCertificateCmdTest {
@Mock
@ -41,24 +40,34 @@ public class GetLoadBalancerSslCertificateCmdTest {
GetLoadBalancerSslCertificateCmd getLoadBalancerSslCertificateCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
getLoadBalancerSslCertificateCmd = new GetLoadBalancerSslCertificateCmd();
Whitebox.setInternalState(getLoadBalancerSslCertificateCmd, "lbMgr", loadBalancingRulesManager);
Whitebox.setInternalState(getLoadBalancerSslCertificateCmd, "id", 1L);
ReflectionTestUtils.setField(getLoadBalancerSslCertificateCmd, "lbMgr", loadBalancingRulesManager);
ReflectionTestUtils.setField(getLoadBalancerSslCertificateCmd, "id", 1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
LoadBalancingRule.LbSslCert lbSslCert = Mockito.mock(LoadBalancingRule.LbSslCert.class);
TlsDataResponse tlsDataResponse = Mockito.mock(TlsDataResponse.class);
Mockito.when(lbSslCert.getCert()).thenReturn("test");
Mockito.when(lbSslCert.getKey()).thenReturn("test");
Mockito.when(lbSslCert.getChain()).thenReturn("test");
Mockito.when(lbSslCert.getCert()).thenReturn("testCrt");
Mockito.when(lbSslCert.getKey()).thenReturn("testKey");
Mockito.when(lbSslCert.getChain()).thenReturn("testChain");
Mockito.when(loadBalancingRulesManager.getLbSslCert(ArgumentMatchers.anyLong())).thenReturn(lbSslCert);
PowerMockito.whenNew(TlsDataResponse.class).withAnyArguments().thenReturn(tlsDataResponse);
getLoadBalancerSslCertificateCmd.execute();
Assert.assertEquals(tlsDataResponse, getLoadBalancerSslCertificateCmd.getResponseObject());
TlsDataResponse response = (TlsDataResponse) getLoadBalancerSslCertificateCmd.getResponseObject();
Assert.assertEquals(Base64.encodeBase64String("testCrt".getBytes()), response.getCrt());
Assert.assertEquals(Base64.encodeBase64String("testChain".getBytes()), response.getChain());
Assert.assertEquals(Base64.encodeBase64String("testKey".getBytes()), response.getKey());
}
}

46
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricAddressGroupCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,64 +29,62 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricAddressGroupCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricAddressGroupCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricAddressGroupCmd listTungstenFabricAddressGroupCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricAddressGroupCmd = new ListTungstenFabricAddressGroupCmd();
listTungstenFabricAddressGroupCmd.tungstenService = tungstenService;
listTungstenFabricAddressGroupCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricAddressGroupCmd.configure();
Whitebox.setInternalState(listTungstenFabricAddressGroupCmd, "addressGroupUuid", "test");
Whitebox.setInternalState(listTungstenFabricAddressGroupCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricAddressGroupCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricAddressGroupCmd, "addressGroupUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricAddressGroupCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricAddressGroupCmd, "pageSize", 10);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricAddressGroupCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricAddressGroupCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenAddressGroup(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricAddressGroupCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricAddressGroupCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricAddressGroupCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenAddressGroup(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricAddressGroupCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricAddressGroupCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricAddressGroupCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

50
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricApplictionPolicySetCmdTest.java → plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricApplicationPolicySetCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,65 +29,63 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricApplictionPolicySetCmd.class)
public class ListTungstenFabricApplictionPolicySetCmdTest {
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricApplicationPolicySetCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricApplictionPolicySetCmd listTungstenFabricApplictionPolicySetCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricApplictionPolicySetCmd = new ListTungstenFabricApplictionPolicySetCmd();
listTungstenFabricApplictionPolicySetCmd.tungstenService = tungstenService;
listTungstenFabricApplictionPolicySetCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricApplictionPolicySetCmd.configure();
Whitebox.setInternalState(listTungstenFabricApplictionPolicySetCmd, "zoneId", 1L);
Whitebox.setInternalState(listTungstenFabricApplictionPolicySetCmd, "applicationPolicySetUuid", "test");
Whitebox.setInternalState(listTungstenFabricApplictionPolicySetCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricApplictionPolicySetCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricApplictionPolicySetCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricApplictionPolicySetCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricApplictionPolicySetCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricApplictionPolicySetCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricApplictionPolicySetCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricApplictionPolicySetCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenApplicationPolicySet(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricApplictionPolicySetCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricApplictionPolicySetCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricApplictionPolicySetCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenApplicationPolicySet(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricApplictionPolicySetCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricApplictionPolicySetCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricApplictionPolicySetCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

49
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricFirewallPolicyCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,65 +29,64 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricFirewallPolicyCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricFirewallPolicyCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricFirewallPolicyCmd listTungstenFabricFirewallPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricFirewallPolicyCmd = new ListTungstenFabricFirewallPolicyCmd();
listTungstenFabricFirewallPolicyCmd.tungstenService = tungstenService;
listTungstenFabricFirewallPolicyCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricFirewallPolicyCmd.configure();
Whitebox.setInternalState(listTungstenFabricFirewallPolicyCmd, "applicationPolicySetUuid", "test");
Whitebox.setInternalState(listTungstenFabricFirewallPolicyCmd, "firewallPolicyUuid", "test");
Whitebox.setInternalState(listTungstenFabricFirewallPolicyCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricFirewallPolicyCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricFirewallPolicyCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricFirewallPolicyCmd, "firewallPolicyUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricFirewallPolicyCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricFirewallPolicyCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricFirewallPolicyCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricFirewallPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricFirewallPolicyCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenFirewallPolicy(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricFirewallPolicyCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricFirewallPolicyCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricFirewallPolicyCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenFirewallPolicy(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricFirewallPolicyCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricFirewallPolicyCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricFirewallPolicyCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

49
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricFirewallRuleCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,65 +29,64 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricFirewallRuleCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricFirewallRuleCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricFirewallRuleCmd listTungstenFabricFirewallRuleCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricFirewallRuleCmd = new ListTungstenFabricFirewallRuleCmd();
listTungstenFabricFirewallRuleCmd.tungstenService = tungstenService;
listTungstenFabricFirewallRuleCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricFirewallRuleCmd.configure();
Whitebox.setInternalState(listTungstenFabricFirewallRuleCmd, "firewallPolicyUuid", "test");
Whitebox.setInternalState(listTungstenFabricFirewallRuleCmd, "firewallRuleUuid", "test");
Whitebox.setInternalState(listTungstenFabricFirewallRuleCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricFirewallRuleCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricFirewallRuleCmd, "firewallPolicyUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricFirewallRuleCmd, "firewallRuleUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricFirewallRuleCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricFirewallRuleCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricFirewallRuleCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricFirewallRuleCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricFirewallRuleCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenFirewallRule(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricFirewallRuleCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricFirewallRuleCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricFirewallRuleCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenFirewallRule(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricFirewallRuleCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricFirewallRuleCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricFirewallRuleCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

39
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricLBHealthMonitorCmdTest.java
View File

@ -16,10 +16,10 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -28,47 +28,46 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricLBHealthMonitorCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricLBHealthMonitorCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricLBHealthMonitorCmd listTungstenFabricLBHealthMonitorCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricLBHealthMonitorCmd = new ListTungstenFabricLBHealthMonitorCmd();
listTungstenFabricLBHealthMonitorCmd.tungstenService = tungstenService;
listTungstenFabricLBHealthMonitorCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricLBHealthMonitorCmd.configure();
Whitebox.setInternalState(listTungstenFabricLBHealthMonitorCmd, "lbID", 1L);
Whitebox.setInternalState(listTungstenFabricLBHealthMonitorCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricLBHealthMonitorCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricLBHealthMonitorCmd, "lbID", 1L);
ReflectionTestUtils.setField(listTungstenFabricLBHealthMonitorCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricLBHealthMonitorCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricLBHealthMonitorCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenFabricLBHealthMonitor(ArgumentMatchers.anyLong())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricLBHealthMonitorCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricLBHealthMonitorCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricLBHealthMonitorCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

49
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricLogicalRouterCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,65 +29,64 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricLogicalRouterCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricLogicalRouterCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricLogicalRouterCmd listTungstenFabricLogicalRouterCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricLogicalRouterCmd = new ListTungstenFabricLogicalRouterCmd();
listTungstenFabricLogicalRouterCmd.tungstenService = tungstenService;
listTungstenFabricLogicalRouterCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricLogicalRouterCmd.configure();
Whitebox.setInternalState(listTungstenFabricLogicalRouterCmd, "networkUuid", "test");
Whitebox.setInternalState(listTungstenFabricLogicalRouterCmd, "logicalRouterUuid", "test");
Whitebox.setInternalState(listTungstenFabricLogicalRouterCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricLogicalRouterCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricLogicalRouterCmd, "networkUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricLogicalRouterCmd, "logicalRouterUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricLogicalRouterCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricLogicalRouterCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricLogicalRouterCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricLogicalRouterCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricLogicalRouterCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listRoutingLogicalRouter(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricLogicalRouterCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricLogicalRouterCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricLogicalRouterCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listRoutingLogicalRouter(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricLogicalRouterCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricLogicalRouterCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricLogicalRouterCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
}

53
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricNetworkCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,66 +29,67 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricNetworkCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricNetworkCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricNetworkCmd listTungstenFabricNetworkCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricNetworkCmd = new ListTungstenFabricNetworkCmd();
listTungstenFabricNetworkCmd.tungstenService = tungstenService;
listTungstenFabricNetworkCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricNetworkCmd.configure();
Whitebox.setInternalState(listTungstenFabricNetworkCmd, "networkUuid", "test");
Whitebox.setInternalState(listTungstenFabricNetworkCmd, "listAll", true);
Whitebox.setInternalState(listTungstenFabricNetworkCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricNetworkCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricNetworkCmd, "networkUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricNetworkCmd, "listAll", true);
ReflectionTestUtils.setField(listTungstenFabricNetworkCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricNetworkCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricNetworkCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricNetworkCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricNetworkCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenNetwork(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyBoolean())).thenReturn(baseResponseList);
PowerMockito.whenNew(BaseResponse.class).withAnyArguments().thenReturn(baseResponse);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricNetworkCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricNetworkCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricNetworkCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenNetwork(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(), ArgumentMatchers.anyBoolean())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricNetworkCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricNetworkCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricNetworkCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
}

49
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricNicCmdTest.java
View File

@ -16,77 +16,78 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricNicCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricNicCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
@InjectMocks
ListTungstenFabricNicCmd listTungstenFabricNicCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricNicCmd = new ListTungstenFabricNicCmd();
listTungstenFabricNicCmd.tungstenService = tungstenService;
listTungstenFabricNicCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricNicCmd.configure();
Whitebox.setInternalState(listTungstenFabricNicCmd, "nicUuid", "test");
Whitebox.setInternalState(listTungstenFabricNicCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricNicCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricNicCmd, "nicUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricNicCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricNicCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricNicCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricNicCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricNicCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenNic(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricNicCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricNicCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricNicCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenNic(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricNicCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricNicCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricNicCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

50
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricPolicyCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,61 +29,58 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricPolicyCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricPolicyCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricPolicyCmd listTungstenFabricPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricPolicyCmd = new ListTungstenFabricPolicyCmd();
listTungstenFabricPolicyCmd.tungstenService = tungstenService;
listTungstenFabricPolicyCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricPolicyCmd.configure();
Whitebox.setInternalState(listTungstenFabricPolicyCmd, "networkId", 1L);
Whitebox.setInternalState(listTungstenFabricPolicyCmd, "addressId", 1L);
Whitebox.setInternalState(listTungstenFabricPolicyCmd, "policyUuid", "test");
Whitebox.setInternalState(listTungstenFabricPolicyCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricPolicyCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "networkId", 1L);
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "addressId", 1L);
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "policyUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricPolicyCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenPolicy(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyLong(),
ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricPolicyCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricPolicyCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricPolicyCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
@ -91,8 +88,9 @@ public class ListTungstenFabricPolicyCmdTest {
ArgumentMatchers.anyLong(),
ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricPolicyCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricPolicyCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricPolicyCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

51
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricPolicyRuleCmdTest.java
View File

@ -16,80 +16,81 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricPolicyRuleCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricPolicyRuleCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
@InjectMocks
ListTungstenFabricPolicyRuleCmd listTungstenFabricPolicyRuleCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricPolicyRuleCmd = new ListTungstenFabricPolicyRuleCmd();
listTungstenFabricPolicyRuleCmd.tungstenService = tungstenService;
listTungstenFabricPolicyRuleCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricPolicyRuleCmd.configure();
Whitebox.setInternalState(listTungstenFabricPolicyRuleCmd, "policyUuid", "test");
Whitebox.setInternalState(listTungstenFabricPolicyRuleCmd, "ruleUuid", "test");
Whitebox.setInternalState(listTungstenFabricPolicyRuleCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricPolicyRuleCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricPolicyRuleCmd, "policyUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricPolicyRuleCmd, "ruleUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricPolicyRuleCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricPolicyRuleCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricPolicyRuleCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricPolicyRuleCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricPolicyRuleCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenPolicyRule(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricPolicyRuleCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricPolicyRuleCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricPolicyRuleCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenPolicyRule(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricPolicyRuleCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricPolicyRuleCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricPolicyRuleCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

40
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricProvidersCmdTest.java
View File

@ -16,10 +16,10 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenProviderService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -28,47 +28,45 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricProvidersCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricProvidersCmdTest {
@Mock
TungstenProviderService tungstenProviderService;
@Mock
ConfigurationService configService;
ListTungstenFabricProvidersCmd listTungstenFabricProvidersCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricProvidersCmd = new ListTungstenFabricProvidersCmd();
listTungstenFabricProvidersCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricProvidersCmd.configure();
Whitebox.setInternalState(listTungstenFabricProvidersCmd, "tungstenProviderService", tungstenProviderService);
Whitebox.setInternalState(listTungstenFabricProvidersCmd, "zoneId", 1L);
Whitebox.setInternalState(listTungstenFabricProvidersCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricProvidersCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricProvidersCmd, "tungstenProviderService", tungstenProviderService);
ReflectionTestUtils.setField(listTungstenFabricProvidersCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricProvidersCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricProvidersCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricProvidersCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenProviderService.listTungstenProvider(ArgumentMatchers.anyLong())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricProvidersCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricProvidersCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricProvidersCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

48
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricServiceGroupCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,64 +29,64 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricServiceGroupCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricServiceGroupCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricServiceGroupCmd listTungstenFabricServiceGroupCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricServiceGroupCmd = new ListTungstenFabricServiceGroupCmd();
listTungstenFabricServiceGroupCmd.tungstenService = tungstenService;
listTungstenFabricServiceGroupCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricServiceGroupCmd.configure();
Whitebox.setInternalState(listTungstenFabricServiceGroupCmd, "serviceGroupUuid", "test");
Whitebox.setInternalState(listTungstenFabricServiceGroupCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricServiceGroupCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricServiceGroupCmd, "serviceGroupUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricServiceGroupCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricServiceGroupCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricServiceGroupCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricServiceGroupCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricServiceGroupCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenServiceGroup(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricServiceGroupCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricServiceGroupCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricServiceGroupCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenServiceGroup(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricServiceGroupCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricServiceGroupCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricServiceGroupCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
}

58
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricTagCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,50 +29,48 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricTagCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricTagCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricTagCmd listTungstenFabricTagCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricTagCmd = new ListTungstenFabricTagCmd();
listTungstenFabricTagCmd.tungstenService = tungstenService;
listTungstenFabricTagCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricTagCmd.configure();
Whitebox.setInternalState(listTungstenFabricTagCmd, "networkUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagCmd, "vmUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagCmd, "nicUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagCmd, "policyUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagCmd, "applicationPolicySetUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagCmd, "tagUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricTagCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "networkUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "vmUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "nicUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "policyUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "tagUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricTagCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricTagCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenTags(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString(),
@ -80,16 +78,17 @@ public class ListTungstenFabricTagCmdTest {
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricTagCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricTagCmd.getResponseObject());
listTungstenFabricTagCmd.execute();
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricTagCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
@ -100,8 +99,9 @@ public class ListTungstenFabricTagCmdTest {
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricTagCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricTagCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricTagCmd.getResponseObject();
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
Assert.assertEquals(baseResponseList, responseList.getResponses());
}
}

47
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricTagTypeCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,64 +29,63 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricTagTypeCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricTagTypeCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricTagTypeCmd listTungstenFabricTagTypeCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricTagTypeCmd = new ListTungstenFabricTagTypeCmd();
listTungstenFabricTagTypeCmd.tungstenService = tungstenService;
listTungstenFabricTagTypeCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricTagTypeCmd.configure();
Whitebox.setInternalState(listTungstenFabricTagTypeCmd, "tagTypeUuid", "test");
Whitebox.setInternalState(listTungstenFabricTagTypeCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricTagTypeCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricTagTypeCmd, "tagTypeUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricTagTypeCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricTagTypeCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricTagTypeCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricTagTypeCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricTagTypeCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenTagTypes(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricTagTypeCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricTagTypeCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricTagTypeCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenTagTypes(ArgumentMatchers.anyLong(),
ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricTagTypeCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricTagTypeCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricTagTypeCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

47
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/ListTungstenFabricVmCmdTest.java
View File

@ -16,11 +16,11 @@
// under the License.
package org.apache.cloudstack.network.tungsten.api.command;
import com.cloud.configuration.ConfigurationService;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.response.ListResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -29,62 +29,61 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(ListTungstenFabricVmCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class ListTungstenFabricVmCmdTest {
@Mock
TungstenService tungstenService;
@Mock
ConfigurationService configService;
ListTungstenFabricVmCmd listTungstenFabricVmCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
listTungstenFabricVmCmd = new ListTungstenFabricVmCmd();
listTungstenFabricVmCmd.tungstenService = tungstenService;
listTungstenFabricVmCmd._configService = configService;
Mockito.when(configService.getDefaultPageSize()).thenReturn(-1L);
listTungstenFabricVmCmd.configure();
Whitebox.setInternalState(listTungstenFabricVmCmd, "vmUuid", "test");
Whitebox.setInternalState(listTungstenFabricVmCmd, "page", 1);
Whitebox.setInternalState(listTungstenFabricVmCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricVmCmd, "vmUuid", "test");
ReflectionTestUtils.setField(listTungstenFabricVmCmd, "page", 1);
ReflectionTestUtils.setField(listTungstenFabricVmCmd, "pageSize", 10);
ReflectionTestUtils.setField(listTungstenFabricVmCmd, "s_maxPageSize", -1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
Whitebox.setInternalState(listTungstenFabricVmCmd, "zoneId", 1L);
ReflectionTestUtils.setField(listTungstenFabricVmCmd, "zoneId", 1L);
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
Mockito.when(tungstenService.listTungstenVm(ArgumentMatchers.anyLong(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricVmCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricVmCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricVmCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
@Test
public void executeAllZoneTest() throws Exception {
BaseResponse baseResponse = Mockito.mock(BaseResponse.class);
List<BaseResponse> baseResponseList = Arrays.asList(baseResponse);
ListResponse<BaseResponse> responseList = Mockito.mock(ListResponse.class);
TungstenProviderVO tungstenProviderVO = Mockito.mock(TungstenProviderVO.class);
List<TungstenProviderVO> tungstenProviderVOList = Arrays.asList(tungstenProviderVO);
Mockito.when(tungstenService.getTungstenProviders()).thenReturn(tungstenProviderVOList);
Mockito.when(tungstenService.listTungstenVm(ArgumentMatchers.anyLong(), ArgumentMatchers.anyString())).thenReturn(baseResponseList);
PowerMockito.whenNew(ListResponse.class).withAnyArguments().thenReturn(responseList);
listTungstenFabricVmCmd.execute();
Assert.assertEquals(responseList, listTungstenFabricVmCmd.getResponseObject());
ListResponse<BaseResponse> responseList = (ListResponse<BaseResponse>) listTungstenFabricVmCmd.getResponseObject();
Assert.assertEquals(baseResponseList, responseList.getResponses());
Assert.assertEquals(Integer.valueOf(1), responseList.getCount());
}
}

21
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/RemoveTungstenFabricNetworkGatewayFromLogicalRouterCmdTest.java
View File

@ -24,18 +24,22 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(MockitoJUnitRunner.class)
public class RemoveTungstenFabricNetworkGatewayFromLogicalRouterCmdTest {
@Mock
@ -43,15 +47,22 @@ public class RemoveTungstenFabricNetworkGatewayFromLogicalRouterCmdTest {
RemoveTungstenFabricNetworkGatewayFromLogicalRouterCmd removeTungstenFabricNetworkGatewayFromLogicalRouterCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
removeTungstenFabricNetworkGatewayFromLogicalRouterCmd =
new RemoveTungstenFabricNetworkGatewayFromLogicalRouterCmd();
removeTungstenFabricNetworkGatewayFromLogicalRouterCmd.tungstenService = tungstenService;
Whitebox.setInternalState(removeTungstenFabricNetworkGatewayFromLogicalRouterCmd, "zoneId", 1L);
Whitebox.setInternalState(removeTungstenFabricNetworkGatewayFromLogicalRouterCmd, "networkUuid", "test");
Whitebox.setInternalState(removeTungstenFabricNetworkGatewayFromLogicalRouterCmd, "logicalRouterUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricNetworkGatewayFromLogicalRouterCmd, "zoneId", 1L);
ReflectionTestUtils.setField(removeTungstenFabricNetworkGatewayFromLogicalRouterCmd, "networkUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricNetworkGatewayFromLogicalRouterCmd, "logicalRouterUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

21
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/RemoveTungstenFabricPolicyCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricPolicyResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class RemoveTungstenFabricPolicyCmdTest {
@Mock
@ -40,14 +44,21 @@ public class RemoveTungstenFabricPolicyCmdTest {
RemoveTungstenFabricPolicyCmd removeTungstenFabricPolicyCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
removeTungstenFabricPolicyCmd = new RemoveTungstenFabricPolicyCmd();
removeTungstenFabricPolicyCmd.tungstenService = tungstenService;
Whitebox.setInternalState(removeTungstenFabricPolicyCmd, "zoneId", 1L);
Whitebox.setInternalState(removeTungstenFabricPolicyCmd, "networkUuid", "test");
Whitebox.setInternalState(removeTungstenFabricPolicyCmd, "policyUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricPolicyCmd, "zoneId", 1L);
ReflectionTestUtils.setField(removeTungstenFabricPolicyCmd, "networkUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricPolicyCmd, "policyUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

21
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/RemoveTungstenFabricPolicyRuleCmdTest.java
View File

@ -24,15 +24,19 @@ import com.cloud.exception.ResourceUnavailableException;
import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricPolicyResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
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.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(MockitoJUnitRunner.class)
public class RemoveTungstenFabricPolicyRuleCmdTest {
@Mock
@ -40,14 +44,21 @@ public class RemoveTungstenFabricPolicyRuleCmdTest {
RemoveTungstenFabricPolicyRuleCmd removeTungstenFabricPolicyRuleCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
removeTungstenFabricPolicyRuleCmd = new RemoveTungstenFabricPolicyRuleCmd();
removeTungstenFabricPolicyRuleCmd.tungstenService = tungstenService;
Whitebox.setInternalState(removeTungstenFabricPolicyRuleCmd, "zoneId", 1L);
Whitebox.setInternalState(removeTungstenFabricPolicyRuleCmd, "policyUuid", "test");
Whitebox.setInternalState(removeTungstenFabricPolicyRuleCmd, "ruleUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricPolicyRuleCmd, "zoneId", 1L);
ReflectionTestUtils.setField(removeTungstenFabricPolicyRuleCmd, "policyUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricPolicyRuleCmd, "ruleUuid", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

27
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/RemoveTungstenFabricTagCmdTest.java
View File

@ -27,14 +27,17 @@ import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
@RunWith(MockitoJUnitRunner.class)
public class RemoveTungstenFabricTagCmdTest {
@Mock
@ -42,18 +45,24 @@ public class RemoveTungstenFabricTagCmdTest {
RemoveTungstenFabricTagCmd removeTungstenFabricTagCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
removeTungstenFabricTagCmd = new RemoveTungstenFabricTagCmd();
removeTungstenFabricTagCmd.tungstenService = tungstenService;
Whitebox.setInternalState(removeTungstenFabricTagCmd, "zoneId", 1L);
Whitebox.setInternalState(removeTungstenFabricTagCmd, "networkUuids", Arrays.asList("test"));
Whitebox.setInternalState(removeTungstenFabricTagCmd, "vmUuids", Arrays.asList("test"));
Whitebox.setInternalState(removeTungstenFabricTagCmd, "nicUuids", Arrays.asList("test"));
Whitebox.setInternalState(removeTungstenFabricTagCmd, "policyUuid", "test");
Whitebox.setInternalState(removeTungstenFabricTagCmd, "applicationPolicySetUuid", "test");
Whitebox.setInternalState(removeTungstenFabricTagCmd, "tagUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "zoneId", 1L);
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "networkUuids", Arrays.asList("test"));
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "vmUuids", Arrays.asList("test"));
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "nicUuids", Arrays.asList("test"));
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "policyUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "applicationPolicySetUuid", "test");
ReflectionTestUtils.setField(removeTungstenFabricTagCmd, "tagUuid", "test");
}
public void tearDown() throws Exception {
closeable.close();
}
@Test

25
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/SynchronizeTungstenFabricDataCmdTest.java
View File

@ -18,6 +18,7 @@ package org.apache.cloudstack.network.tungsten.api.command;
import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -26,13 +27,10 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class)
@PrepareForTest(SynchronizeTungstenFabricDataCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class SynchronizeTungstenFabricDataCmdTest {
@Mock
@ -40,20 +38,25 @@ public class SynchronizeTungstenFabricDataCmdTest {
SynchronizeTungstenFabricDataCmd synchronizeTungstenFabricDataCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
synchronizeTungstenFabricDataCmd = new SynchronizeTungstenFabricDataCmd();
synchronizeTungstenFabricDataCmd.tungstenService = tungstenService;
Whitebox.setInternalState(synchronizeTungstenFabricDataCmd, "tungstenProviderId", 1L);
ReflectionTestUtils.setField(synchronizeTungstenFabricDataCmd, "tungstenProviderId", 1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void executeTest() throws Exception {
SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);
Mockito.when(tungstenService.synchronizeTungstenData(ArgumentMatchers.anyLong())).thenReturn(true);
PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);
synchronizeTungstenFabricDataCmd.execute();
Assert.assertEquals(successResponse, synchronizeTungstenFabricDataCmd.getResponseObject());
Assert.assertTrue(((SuccessResponse) synchronizeTungstenFabricDataCmd.getResponseObject()).getSuccess());
}
}

60
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/api/command/UpdateTungstenFabricLBHealthMonitorCmdTest.java
View File

@ -24,6 +24,7 @@ import com.cloud.utils.db.EntityManager;
import org.apache.cloudstack.network.tungsten.api.response.TungstenFabricLBHealthMonitorResponse;
import org.apache.cloudstack.network.tungsten.dao.TungstenFabricLBHealthMonitorVO;
import org.apache.cloudstack.network.tungsten.service.TungstenService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -32,15 +33,12 @@ import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Optional;
@RunWith(PowerMockRunner.class)
@PrepareForTest(UpdateTungstenFabricLBHealthMonitorCmd.class)
@RunWith(MockitoJUnitRunner.class)
public class UpdateTungstenFabricLBHealthMonitorCmdTest {
@Mock
EntityManager entityManager;
@ -49,20 +47,27 @@ public class UpdateTungstenFabricLBHealthMonitorCmdTest {
UpdateTungstenFabricLBHealthMonitorCmd updateTungstenFabricLBHealthMonitorCmd;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
updateTungstenFabricLBHealthMonitorCmd = new UpdateTungstenFabricLBHealthMonitorCmd();
updateTungstenFabricLBHealthMonitorCmd.tungstenService = tungstenService;
updateTungstenFabricLBHealthMonitorCmd._entityMgr = entityManager;
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "lbId", 1L);
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "type", "HTTP");
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "retry", 1);
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "timeout", 1);
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "interval", 1);
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "httpMethod", "GET");
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "expectedCode", "test");
Whitebox.setInternalState(updateTungstenFabricLBHealthMonitorCmd, "urlPath", "test");
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "lbId", 1L);
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "type", "HTTP");
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "retry", 1);
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "timeout", 1);
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "interval", 1);
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "httpMethod", "GET");
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "expectedCode", "test");
ReflectionTestUtils.setField(updateTungstenFabricLBHealthMonitorCmd, "urlPath", "test");
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
@ -83,13 +88,11 @@ public class UpdateTungstenFabricLBHealthMonitorCmdTest {
@Test
public void executeTest() throws Exception {
updateTungstenFabricLBHealthMonitorCmd.setEntityId(1L);
TungstenFabricLBHealthMonitorResponse tungstenFabricLBHealthMonitorResponse =
Mockito.mock(TungstenFabricLBHealthMonitorResponse.class);
TungstenFabricLBHealthMonitorVO tungstenFabricLBHealthMonitorVO =
Mockito.mock(TungstenFabricLBHealthMonitorVO.class);
tungstenFabricLBHealthMonitorVO.setType("test");
Whitebox.setInternalState(tungstenFabricLBHealthMonitorVO, "id", 1L);
Whitebox.setInternalState(tungstenFabricLBHealthMonitorVO, "uuid", "test");
ReflectionTestUtils.setField(tungstenFabricLBHealthMonitorVO, "id", 1L);
ReflectionTestUtils.setField(tungstenFabricLBHealthMonitorVO, "uuid", "test");
tungstenFabricLBHealthMonitorVO.setRetry(1);
tungstenFabricLBHealthMonitorVO.setTimeout(1);
tungstenFabricLBHealthMonitorVO.setInterval(1);
@ -106,9 +109,22 @@ public class UpdateTungstenFabricLBHealthMonitorCmdTest {
Mockito.when(entityManager.findById(ArgumentMatchers.eq(Network.class), ArgumentMatchers.anyLong())).thenReturn(network);
Mockito.when(entityManager.findById(ArgumentMatchers.eq(DataCenter.class), ArgumentMatchers.anyLong())).thenReturn(dataCenter);
Mockito.when(tungstenService.applyLBHealthMonitor(ArgumentMatchers.anyLong())).thenReturn(true);
PowerMockito.whenNew(TungstenFabricLBHealthMonitorResponse.class).withAnyArguments().thenReturn(tungstenFabricLBHealthMonitorResponse);
updateTungstenFabricLBHealthMonitorCmd.execute();
Assert.assertEquals(tungstenFabricLBHealthMonitorResponse,
updateTungstenFabricLBHealthMonitorCmd.getResponseObject());
TungstenFabricLBHealthMonitorResponse tungstenFabricLBHealthMonitorResponse =
(TungstenFabricLBHealthMonitorResponse) updateTungstenFabricLBHealthMonitorCmd.getResponseObject();
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getType(), tungstenFabricLBHealthMonitorResponse.getType());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getId(), tungstenFabricLBHealthMonitorResponse.getId());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getUuid(), tungstenFabricLBHealthMonitorResponse.getUuid());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getRetry(), tungstenFabricLBHealthMonitorResponse.getRetry());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getTimeout(), tungstenFabricLBHealthMonitorResponse.getTimeout());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getInterval(), tungstenFabricLBHealthMonitorResponse.getInterval());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getHttpMethod(), tungstenFabricLBHealthMonitorResponse.getHttpMethod());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getExpectedCode(), tungstenFabricLBHealthMonitorResponse.getExpectedCode());
Assert.assertEquals(tungstenFabricLBHealthMonitorVO.getUrlPath(), tungstenFabricLBHealthMonitorResponse.getUrlPath());
Assert.assertEquals(dataCenter.getId(), tungstenFabricLBHealthMonitorResponse.getZoneId());
Assert.assertEquals(dataCenter.getName(), tungstenFabricLBHealthMonitorResponse.getZoneName());
}
}

55
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/resource/TungstenResourceTest.java
View File

@ -31,8 +31,7 @@ import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.whenNew;
import net.juniper.tungsten.api.ApiObjectBase;
import net.juniper.tungsten.api.ApiPropertyBase;
@ -159,15 +158,17 @@ import org.apache.cloudstack.network.tungsten.model.TungstenTag;
import org.apache.cloudstack.network.tungsten.service.TungstenApi;
import org.apache.cloudstack.network.tungsten.service.TungstenVRouterApi;
import org.apache.cloudstack.network.tungsten.vrouter.Port;
import org.junit.After;
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.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
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 java.util.ArrayList;
import java.util.Arrays;
@ -177,27 +178,36 @@ import java.util.Map;
import javax.naming.ConfigurationException;
@RunWith(PowerMockRunner.class)
@PrepareForTest({TungstenVRouterApi.class, TungstenResource.class, TungstenNetworkPolicy.class})
@RunWith(MockitoJUnitRunner.class)
public class TungstenResourceTest {
@Mock
TungstenApi tungstenApi;
TungstenResource tungstenResource;
MockedStatic<TungstenVRouterApi> tungstenVRouterApiMocked;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
tungstenResource = new TungstenResource();
tungstenResource.tungstenApi = tungstenApi;
Whitebox.setInternalState(tungstenResource, "vrouterPort", "9091");
mockStatic(TungstenVRouterApi.class);
ReflectionTestUtils.setField(tungstenResource, "vrouterPort", "9091");
tungstenVRouterApiMocked = Mockito.mockStatic(TungstenVRouterApi.class);
Project project = mock(Project.class);
when(project.getUuid()).thenReturn("065eab99-b819-4f3f-8e97-99c2ab22e6ed");
when(tungstenApi.getTungstenProjectByFqn(any())).thenReturn(project);
}
@After
public void tearDown() throws Exception {
closeable.close();
tungstenVRouterApiMocked.close();
}
@Test
public void configureTest() throws ConfigurationException {
Map<String, Object> map = new HashMap<>();
@ -307,7 +317,9 @@ public class TungstenResourceTest {
anyString(), anyString(), anyBoolean())).thenReturn(virtualMachineInterface);
when(tungstenApi.createTungstenInstanceIp(anyString(), anyString(), anyString(), anyString())).thenReturn(
instanceIp);
when(TungstenVRouterApi.addTungstenVrouterPort(anyString(), anyString(), any(Port.class))).thenReturn(true);
tungstenVRouterApiMocked.when(
() -> TungstenVRouterApi.addTungstenVrouterPort(anyString(), anyString(), any(Port.class))
).thenReturn(true);
TungstenAnswer answer = (TungstenAnswer) tungstenResource.executeRequest(command);
assertTrue(answer.getResult());
@ -444,7 +456,9 @@ public class TungstenResourceTest {
TungstenCommand command = new DeleteTungstenVRouterPortCommand("10.0.0.10",
"b604c7f7-1dbc-42d8-bceb-2c0898034a7a");
when(TungstenVRouterApi.deleteTungstenVrouterPort(anyString(), anyString(), anyString())).thenReturn(true);
tungstenVRouterApiMocked.when(
() -> TungstenVRouterApi.deleteTungstenVrouterPort(anyString(), anyString(), anyString())
).thenReturn(true);
TungstenAnswer answer = (TungstenAnswer) tungstenResource.executeRequest(command);
assertTrue(answer.getResult());
@ -543,10 +557,7 @@ public class TungstenResourceTest {
VirtualNetwork virtualNetwork1 = mock(VirtualNetwork.class);
VirtualNetwork virtualNetwork2 = mock(VirtualNetwork.class);
List<VirtualNetwork> virtualNetworkList = Arrays.asList(virtualNetwork1, virtualNetwork2);
TungstenNetworkPolicy tungstenNetworkPolicy = mock(TungstenNetworkPolicy.class);
whenNew(TungstenNetworkPolicy.class).withArguments(networkPolicy, virtualNetworkList)
.thenReturn(tungstenNetworkPolicy);
when(networkPolicy.getUuid()).thenReturn("ac617be6-bf80-4086-9d6a-c05ff78e2264");
when(tungstenApi.getTungstenObjectByName(eq(NetworkPolicy.class), any(), anyString())).thenReturn(
networkPolicy);
@ -556,7 +567,7 @@ public class TungstenResourceTest {
TungstenAnswer answer = (TungstenAnswer) tungstenResource.executeRequest(command);
assertTrue(answer.getResult());
assertEquals(tungstenNetworkPolicy, answer.getTungstenModel());
assertEquals(networkPolicy, ((TungstenNetworkPolicy) answer.getTungstenModel()).getNetworkPolicy());
}
@Test
@ -647,8 +658,6 @@ public class TungstenResourceTest {
when(loadbalancerListener.getUuid()).thenReturn("c877d37a-9ad4-4188-a09a-fb13f57f9be0");
when(loadbalancerPool.getUuid()).thenReturn("baf714fa-80a1-454f-9c32-c4d4a6f5c5a4");
when(tungstenApi.getTungstenObject(eq(VirtualNetwork.class), anyString())).thenReturn(virtualNetwork);
when(tungstenApi.getTungstenObjectByName(eq(FloatingIpPool.class), any(), anyString())).thenReturn(
floatingIpPool);
when(tungstenApi.getSubnetUuid(anyString())).thenReturn("b604c7f7-1dbc-42d8-bceb-2c0898034a7a");
when(tungstenApi.createTungstenLbVmi(anyString(), anyString(), anyString())).thenReturn(
virtualMachineInterface);
@ -952,8 +961,6 @@ public class TungstenResourceTest {
VirtualNetwork virtualNetwork1 = mock(VirtualNetwork.class);
VirtualNetwork virtualNetwork2 = mock(VirtualNetwork.class);
List<VirtualNetwork> virtualNetworks = Arrays.asList(virtualNetwork1, virtualNetwork2);
when(tungstenApi.listTungstenNetworkPolicy(anyString(), anyString())).thenAnswer(networkPoliciesAnswer);
when(tungstenApi.getNetworksFromNetworkPolicy(any(NetworkPolicy.class))).thenReturn(virtualNetworks);
TungstenAnswer answer = (TungstenAnswer) tungstenResource.executeRequest(command);
assertTrue(answer.getResult());
assertNotNull(answer.getTungstenModelList());
@ -1383,10 +1390,6 @@ public class TungstenResourceTest {
VirtualNetwork virtualNetwork1 = mock(VirtualNetwork.class);
VirtualNetwork virtualNetwork2 = mock(VirtualNetwork.class);
Answer<List<ApiObjectBase>> virtualNetworksAnswer = setupApiObjectBaseListAnswer(virtualNetwork1, virtualNetwork2);
when(virtualNetwork1.getUuid()).thenReturn("fe79e06a-1142-11ec-82a8-0242ac130003");
when(virtualNetwork2.getUuid()).thenReturn("efffa88c-1145-11ec-82a8-0242ac130003");
when(tungstenApi.getTungstenObject(eq(LogicalRouter.class), anyString())).thenReturn(logicalRouter);
when(tungstenApi.listConnectedNetworkFromLogicalRouter(any(LogicalRouter.class))).thenAnswer(virtualNetworksAnswer);
when(tungstenApi.addNetworkGatewayToLogicalRouter(anyString(), anyString(), anyString())).thenReturn(logicalRouter);
when(tungstenApi.listConnectedNetworkFromLogicalRouter(any(LogicalRouter.class))).thenAnswer(virtualNetworksAnswer);
TungstenAnswer answer = (TungstenAnswer) tungstenResource.executeRequest(command);
@ -1445,10 +1448,6 @@ public class TungstenResourceTest {
VirtualMachineInterface virtualMachineInterface = mock(VirtualMachineInterface.class);
when(tungstenApi.getTungstenObject(eq(LogicalRouter.class), anyString())).thenReturn(logicalRouter);
when(logicalRouter.getVirtualMachineInterface()).thenReturn(List.of(objectReference));
when(tungstenApi.updateTungstenObject(any(LogicalRouter.class))).thenReturn(true);
when(tungstenApi.getTungstenObject(eq(VirtualMachineInterface.class), anyString())).thenReturn(virtualMachineInterface);
when(tungstenApi.deleteTungstenVmInterface(any(VirtualMachineInterface.class))).thenReturn(true);
when(tungstenApi.deleteTungstenObject(any(LogicalRouter.class))).thenReturn(true);
TungstenAnswer answer = (TungstenAnswer) tungstenResource.executeRequest(command);

3
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenApiTest.java
View File

@ -58,6 +58,8 @@ import org.apache.log4j.Logger;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
import java.io.IOException;
import java.util.ArrayList;
@ -66,6 +68,7 @@ import java.util.Comparator;
import java.util.List;
import java.util.UUID;
@RunWith(MockitoJUnitRunner.class)
public class TungstenApiTest {
private static final Logger s_logger = Logger.getLogger(TungstenApiTest.class);

61
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenElementTest.java
View File

@ -28,7 +28,6 @@ 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 static org.powermock.api.mockito.PowerMockito.mockStatic;
import com.cloud.agent.AgentManager;
import com.cloud.api.ApiDBUtils;
@ -110,24 +109,24 @@ import org.apache.cloudstack.network.tungsten.agent.api.ReleaseTungstenFloatingI
import org.apache.cloudstack.network.tungsten.agent.api.SetupTungstenVRouterCommand;
import org.apache.cloudstack.network.tungsten.agent.api.TungstenAnswer;
import org.apache.cloudstack.network.tungsten.agent.api.UpdateTungstenLoadBalancerHealthMonitorCommand;
import org.apache.cloudstack.network.tungsten.agent.api.UpdateTungstenLoadBalancerListenerCommand;
import org.apache.cloudstack.network.tungsten.agent.api.UpdateTungstenLoadBalancerMemberCommand;
import org.apache.cloudstack.network.tungsten.agent.api.UpdateTungstenLoadBalancerPoolCommand;
import org.apache.cloudstack.network.tungsten.dao.TungstenFabricLBHealthMonitorDao;
import org.apache.cloudstack.network.tungsten.dao.TungstenFabricLBHealthMonitorVO;
import org.junit.After;
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.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ApiDBUtils.class, EncryptionUtil.class})
@RunWith(MockitoJUnitRunner.class)
public class TungstenElementTest {
@Mock
TungstenFabricUtils tungstenFabricUtils;
@ -182,9 +181,15 @@ public class TungstenElementTest {
TungstenElement tungstenElement;
MockedStatic<ApiDBUtils> apiDBUtilsMocked;
MockedStatic<EncryptionUtil> encryptionUtilMocked;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
tungstenElement = new TungstenElement();
tungstenElement.tungstenFabricUtils = tungstenFabricUtils;
tungstenElement.networkModel = networkModel;
@ -212,12 +217,19 @@ public class TungstenElementTest {
tungstenElement.tungstenFabricLBHealthMonitorDao = tungstenFabricLBHealthMonitorDao;
tungstenElement.loadBalancerCertMapDao = loadBalancerCertMapDao;
mockStatic(ApiDBUtils.class);
mockStatic(EncryptionUtil.class);
apiDBUtilsMocked = Mockito.mockStatic(ApiDBUtils.class);
encryptionUtilMocked = Mockito.mockStatic(EncryptionUtil.class);
when(tungstenService.getTungstenProjectFqn(any())).thenReturn("default-domain:default-project");
}
@After
public void tearDown() throws Exception {
apiDBUtilsMocked.close();
encryptionUtilMocked.close();
closeable.close();
}
@Test
public void canHandleSuccessTest() {
Network network = mock(Network.class);
@ -352,9 +364,6 @@ public class TungstenElementTest {
when(lbStickinessPolicy.getMethodName()).thenReturn("AppCookie");
List<Pair<String, String>> pairList = List.of(new Pair<>("cookieName", "cookieValue"));
when(accountMgr.getActiveUser(anyLong())).thenReturn(caller);
when(caller.getApiKey()).thenReturn("apikey");
when(caller.getSecretKey()).thenReturn("secreatekey");
when(lbStickinessPolicy.getParams()).thenReturn(pairList);
when(loadBalancingRule1.getId()).thenReturn(1L);
when(loadBalancingRule1.getState()).thenReturn(FirewallRule.State.Add);
@ -363,8 +372,6 @@ public class TungstenElementTest {
when(loadBalancingRule1.getDefaultPortStart()).thenReturn(443);
when(loadBalancingRule1.getStickinessPolicies()).thenReturn(lbStickinessPolicyList);
when(loadBalancingRule1.getSourceIp()).thenReturn(ip);
when(loadBalancingRule1.getLbSslCert()).thenReturn(lbSslCert);
when(loadBalancingRule1.getUuid()).thenReturn("loadbalancingruleuuid");
when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), any())).thenReturn(publicNetwork);
when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);
when(ipAddressVO.getAddress()).thenReturn(ip);
@ -372,19 +379,15 @@ public class TungstenElementTest {
when(tungstenGuestNetworkIpAddressVO.getGuestIpAddress()).thenReturn(ip);
when(ip.addr()).thenReturn("10.10.10.10");
when(tungstenGuestNetworkIpAddressDao.findByNetworkIdAndPublicIp(anyLong(), anyString())).thenReturn(tungstenGuestNetworkIpAddressVO);
when(ipAddressMgr.acquireGuestIpAddress(any(), any())).thenReturn("192.168.100.100");
when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkLoadbalancerCommand.class), anyLong())).thenReturn(createTungstenNetworkLoadbalancerAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(UpdateTungstenLoadBalancerPoolCommand.class), anyLong())).thenReturn(updateTungstenLoadBalancerPoolAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(UpdateTungstenLoadBalancerMemberCommand.class), anyLong())).thenReturn(updateTungstenLoadBalancerMemberAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(UpdateTungstenLoadBalancerListenerCommand.class), anyLong())).thenReturn(updateTungstenLoadBalancerListenerAnswer);
when(createTungstenNetworkLoadbalancerAnswer.getResult()).thenReturn(true);
when(updateTungstenLoadBalancerPoolAnswer.getResult()).thenReturn(true);
when(updateTungstenLoadBalancerMemberAnswer.getResult()).thenReturn(true);
when(updateTungstenLoadBalancerListenerAnswer.getResult()).thenReturn(true);
when(updateTungstenHealthMonitorAnswer.getResult()).thenReturn(true);
when(configDao.getValue(Config.NetworkLBHaproxyStatsVisbility.key())).thenReturn("enabled");
when(tungstenService.updateLoadBalancer(any(), any())).thenReturn(true);
when(lbDao.listByIpAddress(anyLong())).thenReturn(loadBalancerVOList);
when(EncryptionUtil.generateSignature(anyString(), anyString())).thenReturn("generatedString");
when(tungstenFabricLBHealthMonitorDao.findByLbId(anyLong())).thenReturn(tungstenFabricLBHealthMonitorVO);
when(tungstenFabricUtils.sendTungstenCommand(any(UpdateTungstenLoadBalancerHealthMonitorCommand.class), anyLong())).thenReturn(updateTungstenHealthMonitorAnswer);
@ -427,7 +430,6 @@ public class TungstenElementTest {
when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);
when(ipAddressVO.getAddress()).thenReturn(ip);
when(lbVmMapDao.listByLoadBalancerId(anyLong(), anyBoolean())).thenReturn(loadBalancerVMMapVOList);
when(tungstenGuestNetworkIpAddressVO.getGuestIpAddress()).thenReturn(ip);
when(ip.addr()).thenReturn("10.10.10.10");
when(ipAddressMgr.acquireGuestIpAddress(any(), any())).thenReturn("192.168.100.100");
when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkLoadbalancerCommand.class), anyLong())).thenReturn(createTungstenNetworkLoadbalancerAnswer);
@ -437,8 +439,6 @@ public class TungstenElementTest {
when(updateTungstenLoadBalancerPoolAnswer.getResult()).thenReturn(true);
when(updateTungstenLoadBalancerMemberAnswer.getResult()).thenReturn(true);
when(configDao.getValue(Config.NetworkLBHaproxyStatsVisbility.key())).thenReturn("disabled");
when(tungstenService.updateLoadBalancerSsl(any(), any())).thenReturn(false);
when(lbDao.listByIpAddress(anyLong())).thenReturn(loadBalancerVOList);
when(tungstenFabricLBHealthMonitorDao.findByLbId(anyLong())).thenReturn(tungstenFabricLBHealthMonitorVO);
when(updateTungstenHealthMonitorAnswer.getResult()).thenReturn(true);
when(tungstenFabricUtils.sendTungstenCommand(any(UpdateTungstenLoadBalancerHealthMonitorCommand.class), anyLong())).thenReturn(updateTungstenHealthMonitorAnswer);
@ -466,11 +466,8 @@ public class TungstenElementTest {
when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);
when(ipAddressVO.getAddress()).thenReturn(ip1);
when(ip1.addr()).thenReturn("10.10.10.10");
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenLoadBalancerListenerCommand.class), anyLong())).thenReturn(deleteTungstenLoadBalancerListenerAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenLoadBalancerCommand.class), anyLong())).thenReturn(deleteTungstenLoadBalancerCommand);
when(deleteTungstenLoadBalancerListenerAnswer.getResult()).thenReturn(true);
when(deleteTungstenLoadBalancerCommand.getResult()).thenReturn(true);
when(tungstenService.updateLoadBalancerSsl(any(), any())).thenReturn(false);
when(lbDao.listByIpAddress(anyLong())).thenReturn(loadBalancerVOList1);
when(tungstenGuestNetworkIpAddressDao.findByNetworkIdAndPublicIp(anyLong(),anyString())).thenReturn(tungstenGuestNetworkIpAddressVO);
when(tungstenGuestNetworkIpAddressDao.remove(anyLong())).thenReturn(false);
@ -497,15 +494,11 @@ public class TungstenElementTest {
when(loadBalancingRule.getSourceIp()).thenReturn(ip);
when(loadBalancingRule.getState()).thenReturn(FirewallRule.State.Revoke);
when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);
when(ipAddressVO.getAddress()).thenReturn(ip);
when(ip.addr()).thenReturn("10.10.10.10");
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenLoadBalancerListenerCommand.class), anyLong())).thenReturn(deleteTungstenLoadBalancerListenerAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenLoadBalancerCommand.class), anyLong())).thenReturn(deleteTungstenLoadBalancerCommand);
when(deleteTungstenLoadBalancerListenerAnswer.getResult()).thenReturn(true);
when(deleteTungstenLoadBalancerCommand.getResult()).thenReturn(true);
when(tungstenService.updateLoadBalancer(any(), any())).thenReturn(true);
when(lbDao.listByIpAddress(anyLong())).thenReturn(loadBalancerVOList);
when(tungstenGuestNetworkIpAddressDao.findByNetworkIdAndPublicIp(anyLong(),anyString())).thenReturn(tungstenGuestNetworkIpAddressVO);
assertTrue(tungstenElement.applyLBRules(network, loadBalancingRuleList));
}
@ -700,10 +693,6 @@ public class TungstenElementTest {
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmInterfaceCommand.class), anyLong())).thenReturn(deleteVmiAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmCommand.class), anyLong())).thenReturn(deleteVmAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteTungstenNetworkPolicyAnswer);
when(deleteTungstenVRouterPortAnswer.getResult()).thenReturn(true);
when(deleteVmiAnswer.getResult()).thenReturn(true);
when(deleteVmAnswer.getResult()).thenReturn(true);
when(deleteTungstenNetworkPolicyAnswer.getResult()).thenReturn(true);
assertTrue(tungstenElement.release(network, nicProfile, virtualMachineProfile, reservationContext));
}
@ -720,7 +709,6 @@ public class TungstenElementTest {
TungstenAnswer deleteVmiAnswer = mock(TungstenAnswer.class);
TungstenAnswer deleteVmAnswer = mock(TungstenAnswer.class);
when(nicProfile.getIPv4Address()).thenReturn("192.168.100.100");
when(network.getTrafficType()).thenReturn(Networks.TrafficType.Management);
when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
when(hostDao.findById(anyLong())).thenReturn(host);
@ -728,9 +716,6 @@ public class TungstenElementTest {
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(deleteTungstenVRouterPortAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmInterfaceCommand.class), anyLong())).thenReturn(deleteVmiAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmCommand.class), anyLong())).thenReturn(deleteVmAnswer);
when(deleteTungstenVRouterPortAnswer.getResult()).thenReturn(true);
when(deleteVmiAnswer.getResult()).thenReturn(true);
when(deleteVmAnswer.getResult()).thenReturn(true);
assertTrue(tungstenElement.release(network, nicProfile, virtualMachineProfile, reservationContext));
}
@ -746,7 +731,6 @@ public class TungstenElementTest {
TungstenAnswer deleteTungstenVRouterPortAnswer = mock(TungstenAnswer.class);
TungstenAnswer deleteVmiAnswer = mock(TungstenAnswer.class);
when(nicProfile.getIPv4Address()).thenReturn("192.168.100.100");
when(network.getTrafficType()).thenReturn(Networks.TrafficType.Management);
when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
when(hostDao.findById(anyLong())).thenReturn(host);
@ -754,8 +738,6 @@ public class TungstenElementTest {
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(deleteTungstenVRouterPortAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmInterfaceCommand.class), anyLong())).thenReturn(deleteVmiAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmCommand.class), anyLong())).thenThrow(IllegalArgumentException.class);
when(deleteTungstenVRouterPortAnswer.getResult()).thenReturn(true);
when(deleteVmiAnswer.getResult()).thenReturn(true);
tungstenElement.release(network, nicProfile, virtualMachineProfile, reservationContext);
}
@ -971,7 +953,6 @@ public class TungstenElementTest {
when(firewallRuleVO.getPurpose()).thenReturn(FirewallRule.Purpose.Firewall);
when(firewallRuleVO.getTrafficType()).thenReturn(FirewallRule.TrafficType.Ingress);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteNetworkPolicyAnswer);
when(deleteNetworkPolicyAnswer.getResult()).thenReturn(true);
assertTrue(tungstenElement.applyFWRules(network, List.of(firewallRuleVO)));
}

14
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenFabricUtilsTest.java
View File

@ -28,11 +28,15 @@ import com.cloud.network.dao.TungstenProviderDao;
import com.cloud.network.element.TungstenProviderVO;
import org.apache.cloudstack.network.tungsten.agent.api.TungstenAnswer;
import org.apache.cloudstack.network.tungsten.agent.api.TungstenCommand;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class TungstenFabricUtilsTest {
@Mock
AgentManager agentMgr;
@ -41,14 +45,21 @@ public class TungstenFabricUtilsTest {
TungstenFabricUtils tungstenFabricUtils;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
tungstenFabricUtils = new TungstenFabricUtils();
tungstenFabricUtils.agentMgr = agentMgr;
tungstenFabricUtils.tungstenProviderDao = tungstenProviderDao;
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void sendTungstenCommandSuccessTest() {
TungstenProviderVO tungstenProviderVO = mock(TungstenProviderVO.class);
@ -88,7 +99,6 @@ public class TungstenFabricUtilsTest {
when(tungstenProviderDao.findByZoneId(anyLong())).thenReturn(tungstenProviderVO);
when(agentMgr.easySend(anyLong(), any(TungstenCommand.class))).thenReturn(tungstenAnswer);
when(tungstenAnswer.getResult()).thenReturn(false);
when(tungstenAnswer.getDetails()).thenReturn("");
tungstenFabricUtils.sendTungstenCommand(tungstenCommand, anyLong());
}

35
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenGuestNetworkGuruTest.java
View File

@ -85,27 +85,25 @@ import org.apache.cloudstack.network.tungsten.agent.api.DeleteTungstenVRouterPor
import org.apache.cloudstack.network.tungsten.agent.api.DeleteTungstenVmCommand;
import org.apache.cloudstack.network.tungsten.agent.api.DeleteTungstenVmInterfaceCommand;
import org.apache.cloudstack.network.tungsten.agent.api.GetTungstenNatIpCommand;
import org.apache.cloudstack.network.tungsten.agent.api.ReleaseTungstenFloatingIpCommand;
import org.apache.cloudstack.network.tungsten.agent.api.SetTungstenNetworkGatewayCommand;
import org.apache.cloudstack.network.tungsten.agent.api.SetupTungstenVRouterCommand;
import org.apache.cloudstack.network.tungsten.agent.api.TungstenAnswer;
import org.apache.cloudstack.network.tungsten.agent.api.TungstenCommand;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest(TungstenGuestNetworkGuru.class)
@RunWith(MockitoJUnitRunner.class)
public class TungstenGuestNetworkGuruTest {
@Mock
@ -155,14 +153,16 @@ public class TungstenGuestNetworkGuruTest {
TungstenGuestNetworkGuru guru;
AutoCloseable closeable;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
guru = new TungstenGuestNetworkGuru();
Whitebox.setInternalState(guru, "_physicalNetworkDao", physicalNetworkDao);
Whitebox.setInternalState(guru, "_dcDao", dcDao);
Whitebox.setInternalState(guru, "_networkModel", networkModel);
Whitebox.setInternalState(guru, "_nicDao", nicDao);
ReflectionTestUtils.setField(guru, "_physicalNetworkDao", physicalNetworkDao);
ReflectionTestUtils.setField(guru, "_dcDao", dcDao);
ReflectionTestUtils.setField(guru, "_networkModel", networkModel);
ReflectionTestUtils.setField(guru, "_nicDao", nicDao);
guru.networkOfferingServiceMapDao = ntwkOfferingSrvcDao;
guru.tungstenFabricUtils = tungstenFabricUtils;
guru.tungstenService = tungstenService;
@ -180,10 +180,8 @@ public class TungstenGuestNetworkGuruTest {
when(dc.getNetworkType()).thenReturn(DataCenter.NetworkType.Advanced);
when(dc.getGuestNetworkCidr()).thenReturn("10.1.1.1/24");
when(dc.getId()).thenReturn(1L);
when(dcDao.findById(anyLong())).thenReturn(dc);
when(physicalNetwork.getId()).thenReturn(1L);
when(physicalNetwork.getIsolationMethods()).thenReturn(List.of("TF"));
when(physicalNetworkDao.findById(anyLong())).thenReturn(physicalNetwork);
@ -198,6 +196,11 @@ public class TungstenGuestNetworkGuruTest {
when(plan.getPhysicalNetworkId()).thenReturn(1L);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void testIsMyIsolationMethod() {
assertTrue(guru.isMyIsolationMethod(physicalNetwork));
@ -401,13 +404,7 @@ public class TungstenGuestNetworkGuruTest {
final VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);
final HostVO host = mock(HostVO.class);
when(vm.getType()).thenReturn(VirtualMachine.Type.User);
when(hostDao.findById(anyLong())).thenReturn(host);
when(ipAddressDao.findByAssociatedVmId(anyLong())).thenReturn(ipAddressVO);
when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), any())).thenReturn(new NetworkVO());
when(
tungstenFabricUtils.sendTungstenCommand(any(ReleaseTungstenFloatingIpCommand.class), anyLong())).thenReturn(
new TungstenAnswer(new TungstenCommand(), true, ""));
when(
tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(
new TungstenAnswer(new TungstenCommand(), true, ""));

25
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenIntrospectApiTest.java
View File

@ -18,27 +18,34 @@ package org.apache.cloudstack.network.tungsten.service;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.anyString;
import static org.powermock.api.mockito.PowerMockito.mock;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
import org.apache.cloudstack.network.tungsten.vrouter.IntrospectApiConnector;
import org.apache.cloudstack.network.tungsten.vrouter.IntrospectApiConnectorFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.mockito.MockedStatic;
import org.mockito.junit.MockitoJUnitRunner;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
@RunWith(PowerMockRunner.class)
@PrepareForTest(IntrospectApiConnectorFactory.class)
@RunWith(MockitoJUnitRunner.class)
public class TungstenIntrospectApiTest {
MockedStatic<IntrospectApiConnectorFactory> introspectApiConnectorFactoryMocked;
@Before
public void setup() {
mockStatic(IntrospectApiConnectorFactory.class);
introspectApiConnectorFactoryMocked = mockStatic(IntrospectApiConnectorFactory.class);
}
@After
public void tearDown() {
introspectApiConnectorFactoryMocked.close();
}
@Test
@ -48,7 +55,7 @@ public class TungstenIntrospectApiTest {
NodeList nodeList = mock(NodeList.class);
Node node = mock(Node.class);
when(IntrospectApiConnectorFactory.getInstance(anyString(), anyString())).thenReturn(introspectApiConnector);
introspectApiConnectorFactoryMocked.when(() -> IntrospectApiConnectorFactory.getInstance(anyString(), anyString())).thenReturn(introspectApiConnector);
when(introspectApiConnector.getSnhItfReq(anyString())).thenReturn(document);
when(document.getElementsByTagName(anyString())).thenReturn(nodeList);
when(nodeList.getLength()).thenReturn(1);

15
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenProviderServiceTest.java
View File

@ -38,15 +38,19 @@ import com.cloud.utils.exception.CloudRuntimeException;
import org.apache.cloudstack.api.BaseResponse;
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.network.tungsten.api.command.CreateTungstenFabricProviderCmd;
import org.junit.After;
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 java.util.Arrays;
import java.util.List;
@RunWith(MockitoJUnitRunner.class)
public class TungstenProviderServiceTest {
@Mock
@ -70,9 +74,11 @@ public class TungstenProviderServiceTest {
TungstenProviderServiceImpl tungstenProviderService;
AutoCloseable closeable;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
tungstenProviderService = new TungstenProviderServiceImpl();
tungstenProviderService.zoneDao = dcDao;
tungstenProviderService.resourceMgr = resourceMgr;
@ -86,8 +92,11 @@ public class TungstenProviderServiceTest {
when(zone.getName()).thenReturn("ZoneName");
when(resourceMgr.addHost(anyLong(), any(), any(), anyMap())).thenReturn(host);
when(host.getId()).thenReturn(1L);
when(domainDao.listAll()).thenReturn(null);
when(projectDao.listAll()).thenReturn(null);
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test

86
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenServiceImplTest.java
View File

@ -27,8 +27,6 @@ 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 static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.whenNew;
import com.cloud.agent.AgentManager;
import com.cloud.agent.api.Answer;
@ -193,7 +191,6 @@ import org.apache.cloudstack.network.tungsten.agent.api.RemoveTungstenPolicyRule
import org.apache.cloudstack.network.tungsten.agent.api.RemoveTungstenSecondaryIpAddressCommand;
import org.apache.cloudstack.network.tungsten.agent.api.RemoveTungstenSecurityGroupRuleCommand;
import org.apache.cloudstack.network.tungsten.agent.api.RemoveTungstenTagCommand;
import org.apache.cloudstack.network.tungsten.agent.api.RemoveTungstenVmFromSecurityGroupCommand;
import org.apache.cloudstack.network.tungsten.agent.api.SetupTungstenVRouterCommand;
import org.apache.cloudstack.network.tungsten.agent.api.TungstenAnswer;
import org.apache.cloudstack.network.tungsten.agent.api.UpdateLoadBalancerServiceInstanceCommand;
@ -205,21 +202,22 @@ import org.apache.cloudstack.network.tungsten.model.TungstenLogicalRouter;
import org.apache.cloudstack.network.tungsten.model.TungstenNetworkPolicy;
import org.apache.cloudstack.network.tungsten.model.TungstenRule;
import org.apache.cloudstack.network.tungsten.model.TungstenTag;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockedConstruction;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
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.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.List;
@RunWith(PowerMockRunner.class)
@PrepareForTest({Transaction.class, TungstenServiceImpl.class})
@RunWith(MockitoJUnitRunner.class)
public class TungstenServiceImplTest {
@Mock
MessageBus messageBus;
@ -278,9 +276,11 @@ public class TungstenServiceImplTest {
TungstenServiceImpl tungstenService;
AutoCloseable closeable;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
closeable = MockitoAnnotations.openMocks(this);
tungstenService = new TungstenServiceImpl();
tungstenService.projectDao = projectDao;
tungstenService.tungstenProviderDao = tungstenProviderDao;
@ -311,6 +311,11 @@ public class TungstenServiceImplTest {
tungstenService.messageBus = messageBus;
}
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test
public void createTungstenFloatingIpTest() throws Exception {
IPAddressVO ipAddressVO = mock(IPAddressVO.class);
@ -323,7 +328,7 @@ public class TungstenServiceImplTest {
when(createTungstenFloatingIpAnswer.getResult()).thenReturn(true);
when(ipAddressVO.getAddress()).thenReturn(ip);
assertTrue(Whitebox.invokeMethod(tungstenService, "createTungstenFloatingIp", 1L, ipAddressVO));
assertTrue(ReflectionTestUtils.invokeMethod(tungstenService, "createTungstenFloatingIp", 1L, ipAddressVO));
}
@Test
@ -336,7 +341,7 @@ public class TungstenServiceImplTest {
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenFloatingIpCommand.class), anyLong())).thenReturn(deleteTungstenFloatingIpAnswer);
when(deleteTungstenFloatingIpAnswer.getResult()).thenReturn(true);
assertTrue(Whitebox.invokeMethod(tungstenService, "deleteTungstenFloatingIp", 1L, ipAddressVO));
assertTrue(ReflectionTestUtils.invokeMethod(tungstenService, "deleteTungstenFloatingIp", 1L, ipAddressVO));
}
@Test
@ -349,7 +354,7 @@ public class TungstenServiceImplTest {
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenDomainCommand.class), anyLong())).thenReturn(deleteTungstenDomainAnswer);
when(deleteTungstenDomainAnswer.getResult()).thenReturn(true);
assertTrue(Whitebox.invokeMethod(tungstenService, "deleteTungstenDomain", domainVO));
assertTrue(ReflectionTestUtils.invokeMethod(tungstenService, "deleteTungstenDomain", domainVO));
}
@Test
@ -362,7 +367,7 @@ public class TungstenServiceImplTest {
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenProjectCommand.class), anyLong())).thenReturn(deleteTungstenProjectAnswer);
when(deleteTungstenProjectAnswer.getResult()).thenReturn(true);
assertTrue(Whitebox.invokeMethod(tungstenService, "deleteTungstenProject", projectVO));
assertTrue(ReflectionTestUtils.invokeMethod(tungstenService, "deleteTungstenProject", projectVO));
}
@Test
@ -451,12 +456,10 @@ public class TungstenServiceImplTest {
when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(),
eq(Networks.TrafficType.Management))).thenReturn(managementNetwork);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteTungstenManagementPolicyAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenFabricNetworkCommand.class), anyLong())).thenReturn(getTungstenFabricNetworkAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteTungstenFabricPolicyAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkCommand.class), anyLong())).thenReturn(deleteTungstenNetworkAnswer);
when(getTungstenFabricNetworkAnswer.getApiObjectBase()).thenReturn(fabricVirtualNetwork);
when(deleteTungstenManagementPolicyAnswer.getResult()).thenReturn(true);
when(getTungstenFabricNetworkAnswer.getResult()).thenReturn(true);
when(deleteTungstenFabricPolicyAnswer.getResult()).thenReturn(true);
when(deleteTungstenNetworkAnswer.getResult()).thenReturn(true);
@ -472,7 +475,6 @@ public class TungstenServiceImplTest {
TungstenAnswer getTungstenNetworkDnsAnswer = mock(TungstenAnswer.class);
DataCenterIpAddressVO dataCenterIpAddressVO = mock(DataCenterIpAddressVO.class);
when(hostPodVO.getDescription()).thenReturn("192.168.100.100-192.168.100.200");
when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(),
eq(Networks.TrafficType.Management))).thenReturn(managementNetwork);
when(tungstenFabricUtils.sendTungstenCommand(any(RemoveTungstenNetworkSubnetCommand.class), anyLong())).thenReturn(removeTungstenNetworkSubnetAnswer);
@ -543,7 +545,6 @@ public class TungstenServiceImplTest {
when(applyTungstenPolicyAnswer.getResult()).thenReturn(true);
when(publicNetwork.getTrafficType()).thenReturn(Networks.TrafficType.Public);
when(createTungstenPolicyAnswer.getApiObjectBase()).thenReturn(networkPolicy);
when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);
when(ipAddressDao.mark(anyLong(), any(Ip.class))).thenReturn(true);
assertTrue(tungstenService.addPublicNetworkSubnet(vlanVO));
@ -729,19 +730,19 @@ public class TungstenServiceImplTest {
TungstenSecurityGroupRuleVO tungstenSecurityGroupRuleVO = mock(TungstenSecurityGroupRuleVO.class);
TungstenAnswer createTungstenSecurityGroupAnswer = mock(TungstenAnswer.class);
TungstenAnswer addTungstenSecurityGroupRuleAnswer = mock(TungstenAnswer.class);
mockStatic(Transaction.class);
when(projectDao.findByProjectAccountId(anyLong())).thenReturn(projectVO);
when(tungstenProviderDao.findAll()).thenReturn(List.of(tungstenProviderVO));
when(domainDao.findById(anyLong())).thenReturn(domainVO);
when(projectDao.findByUuid(anyString())).thenReturn(projectVO);
when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenSecurityGroupCommand.class), anyLong())).thenReturn(createTungstenSecurityGroupAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(AddTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(addTungstenSecurityGroupRuleAnswer);
when(createTungstenSecurityGroupAnswer.getResult()).thenReturn(true);
when(addTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
PowerMockito.when(Transaction.execute(any(TransactionCallback.class))).thenReturn(List.of(tungstenSecurityGroupRuleVO));
assertTrue(tungstenService.createTungstenSecurityGroup(securityGroup));
try (MockedStatic<Transaction> transactionMocked = Mockito.mockStatic(Transaction.class)) {
transactionMocked.when(() -> Transaction.execute(any(TransactionCallback.class))).thenReturn(List.of(tungstenSecurityGroupRuleVO));
assertTrue(tungstenService.createTungstenSecurityGroup(securityGroup));
}
}
@Test
@ -774,7 +775,6 @@ public class TungstenServiceImplTest {
when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenSecurityGroupCommand.class), anyLong())).thenReturn(getTungstenSecurityGroupAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(RemoveTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(removeTungstenSecurityGroupRuleAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(AddTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(addTungstenSecurityGroupRuleAnswer);
when(getTungstenSecurityGroupAnswer.getResult()).thenReturn(true);
when(removeTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
when(addTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
when(getTungstenSecurityGroupAnswer.getApiObjectBase()).thenReturn(securityGroup);
@ -807,7 +807,6 @@ public class TungstenServiceImplTest {
when(securityGroupDao.findById(anyLong())).thenReturn(securityGroupVO);
when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenSecurityGroupCommand.class), anyLong())).thenReturn(getTungstenSecurityGroupAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(AddTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(addTungstenSecurityGroupRuleAnswer);
when(getTungstenSecurityGroupAnswer.getResult()).thenReturn(true);
when(addTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
when(getTungstenSecurityGroupAnswer.getApiObjectBase()).thenReturn(securityGroup);
when(securityRule.getRuleType()).thenReturn(SecurityRule.SecurityRuleType.IngressRule);
@ -860,7 +859,6 @@ public class TungstenServiceImplTest {
when(tungstenProviderDao.findAll()).thenReturn(List.of(tungstenProviderVO));
when(securityGroupDao.findById(anyLong())).thenReturn(securityGroupVO);
when(securityRule.getRuleType()).thenReturn(SecurityRule.SecurityRuleType.IngressRule);
when(securityRule.getType()).thenReturn("ingress");
when(tungstenFabricUtils.sendTungstenCommand(any(RemoveTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(removeTungstenSecurityGroupRuleAnswer);
when(removeTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
when(securityRule.getAllowedNetworkId()).thenReturn(null);
@ -945,7 +943,6 @@ public class TungstenServiceImplTest {
@Test
public void addTungstenPolicyRuleTest() throws Exception {
AddTungstenPolicyRuleCommand addTungstenPolicyRuleCommand = mock(AddTungstenPolicyRuleCommand.class);
TungstenAnswer addTungstenPolicyRuleAnswer = mock(TungstenAnswer.class);
NetworkPolicy networkPolicy = mock(NetworkPolicy.class);
PolicyEntriesType policyEntriesType = mock(PolicyEntriesType.class);
@ -962,8 +959,7 @@ public class TungstenServiceImplTest {
when(addTungstenPolicyRuleAnswer.getApiObjectBase()).thenReturn(networkPolicy);
when(networkPolicy.getEntries()).thenReturn(policyEntriesType);
when(policyEntriesType.getPolicyRule()).thenReturn(List.of(policyRuleType));
whenNew(AddTungstenPolicyRuleCommand.class).withAnyArguments().thenReturn(addTungstenPolicyRuleCommand);
PowerMockito.when(addTungstenPolicyRuleCommand, "getUuid").thenReturn("8b4637b6-5629-46de-8fb2-d0b0502bfa85");
when(policyRuleType.getRuleUuid()).thenReturn("8b4637b6-5629-46de-8fb2-d0b0502bfa85");
when(policyRuleType.getActionList()).thenReturn(actionListType);
when(actionListType.getSimpleAction()).thenReturn("pass");
@ -973,9 +969,15 @@ public class TungstenServiceImplTest {
when(policyRuleType.getDstAddresses()).thenReturn(List.of(addressType));
when(policyRuleType.getDstPorts()).thenReturn(List.of(portType));
assertNotNull(tungstenService.addTungstenPolicyRule(1L, "948f421c-edde-4518-a391-09299cc25dc2", "pass",
"<>", "tcp", "network1", "192.168.100.100", 32, 80, 80,
"network2", "192.168.200.200", 32, 80, 80));
try (MockedConstruction<AddTungstenPolicyRuleCommand> ignored =
Mockito.mockConstruction(AddTungstenPolicyRuleCommand.class, (mock, context) -> {
when(mock.getUuid()).thenReturn("8b4637b6-5629-46de-8fb2-d0b0502bfa85");
})) {
assertNotNull(tungstenService.addTungstenPolicyRule(1L, "948f421c-edde-4518-a391-09299cc25dc2", "pass",
"<>", "tcp", "network1", "192.168.100.100", 32, 80, 80,
"network2", "192.168.200.200", 32, 80, 80));
}
}
@Test
@ -1189,7 +1191,6 @@ public class TungstenServiceImplTest {
doReturn(List.of(virtualMachine)).when(tungstenTag).getVirtualMachineList();
doReturn(List.of(virtualMachineInterface)).when(tungstenTag).getVirtualMachineInterfaceList();
doReturn(List.of(networkPolicy)).when(tungstenTag).getNetworkPolicyList();
doReturn(List.of(applicationPolicySet)).when(tungstenTag).getApplicationPolicySetList();
assertNotNull(tungstenService.listTungstenTags(1L, "948f421c-edde-4518-a391-09299cc25dc2"
, "8b4637b6-5629-46de-8fb2-d0b0502bfa85", "8d097a79-a38d-4db4-8a41-16f15d9c5afa", "a329662e-1805-4a89-9b05-2b818ea35978",
@ -1616,10 +1617,6 @@ public class TungstenServiceImplTest {
when(vlan.getIp6Cidr()).thenReturn("fd00::1/64");
when(vlan.getIp6Range()).thenReturn("fd00::100-fd00::200");
when(getTungstenNetworkDnsAnswer.getDetails()).thenReturn("192.168.1.150");
when(network.getTrafficType()).thenReturn(Networks.TrafficType.Guest);
when(network.getGuestType()).thenReturn(Network.GuestType.Shared);
when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);
when(ipAddressDao.mark(anyLong(), any(Ip.class))).thenReturn(true);
when(createTungstenSharedNetworkAnswer.getApiObjectBase()).thenReturn(apiObjectBase);
when(apiObjectBase.getQualifiedName()).thenReturn(List.of("network"));
when(tungstenProviderVO.getGateway()).thenReturn("192.168.100.1");
@ -1648,7 +1645,6 @@ public class TungstenServiceImplTest {
when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenSecurityGroupCommand.class), anyLong())).thenReturn(getTungstenSecurityGroupAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(AddTungstenVmToSecurityGroupCommand.class), anyLong())).thenReturn(addTungstenVmToSecurityGroupAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(AddTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(addTungstenSecurityGroupRuleAnswer);
when(getTungstenSecurityGroupAnswer.getResult()).thenReturn(true);
when(addTungstenVmToSecurityGroupAnswer.getResult()).thenReturn(true);
when(addTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
when(getTungstenSecurityGroupAnswer.getApiObjectBase()).thenReturn(securityGroup);
@ -1678,22 +1674,6 @@ public class TungstenServiceImplTest {
when(dataCenterDao.findById(anyLong())).thenReturn(dataCenterVO);
when(dataCenterVO.isSecurityGroupEnabled()).thenReturn(true);
when(securityGroupManager.getSecurityGroupsForVm(anyLong())).thenReturn(List.of(securityGroupVO));
when(tungstenFabricUtils.sendTungstenCommand(any(RemoveTungstenVmFromSecurityGroupCommand.class), anyLong())).thenReturn(removeTungstenVmFromSecurityGroupAnswer);
when(tungstenFabricUtils.sendTungstenCommand(any(RemoveTungstenSecurityGroupRuleCommand.class), anyLong())).thenReturn(removeTungstenSecurityGroupRuleAnswer);
when(removeTungstenVmFromSecurityGroupAnswer.getResult()).thenReturn(true);
when(removeTungstenSecurityGroupRuleAnswer.getResult()).thenReturn(true);
when(nicDao.findDefaultNicForVM(anyLong())).thenReturn(nicVO);
when(nicVO.getBroadcastUri()).thenReturn(Networks.BroadcastDomainType.TUNGSTEN.toUri("tf"));
when(securityGroupRuleDao.listByAllowedSecurityGroupId(anyLong())).thenReturn(List.of(securityGroupRuleVO));
when(nicVO.getIPv4Address()).thenReturn("192.168.100.100");
when(nicVO.getIPv6Address()).thenReturn("fd00::1");
when(nicVO.getSecondaryIp()).thenReturn(true);
when(nicSecIpDao.getSecondaryIpAddressesForNic(anyLong())).thenReturn(List.of("192.168.100.200"));
when(securityGroupRuleVO.getProtocol()).thenReturn(NetUtils.ALL_PROTO);
when(tungstenSecurityGroupRuleDao.expunge(anyLong())).thenReturn(true);
when(tungstenSecurityGroupRuleDao.listByRuleTarget(anyString())).thenReturn(List.of(tungstenSecurityGroupRuleVO));
when(securityGroupDao.findById(anyLong())).thenReturn(securityGroupVO);
assertTrue(tungstenService.removeTungstenVmSecurityGroup(vmInstanceVO));
}

23
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/service/TungstenVRouterApiTest.java
View File

@ -20,27 +20,34 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.powermock.api.mockito.PowerMockito.mock;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.apache.cloudstack.network.tungsten.vrouter.Port;
import org.apache.cloudstack.network.tungsten.vrouter.VRouterApiConnector;
import org.apache.cloudstack.network.tungsten.vrouter.VRouterApiConnectorFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
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;
import java.io.IOException;
@RunWith(PowerMockRunner.class)
@PrepareForTest(VRouterApiConnectorFactory.class)
@RunWith(MockitoJUnitRunner.class)
public class TungstenVRouterApiTest {
MockedStatic<VRouterApiConnectorFactory> vRouterApiConnectorFactoryMocked;
@Before
public void setup() {
mockStatic(VRouterApiConnectorFactory.class);
vRouterApiConnectorFactoryMocked = Mockito.mockStatic(VRouterApiConnectorFactory.class);
}
@After
public void tearDown() {
vRouterApiConnectorFactoryMocked.close();
}
@Test

40
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/vrouter/IntrospectApiConnectorImplTest.java
View File

@ -27,12 +27,13 @@ import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.junit.After;
import org.junit.Before;
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;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
@ -43,17 +44,26 @@ import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
@RunWith(PowerMockRunner.class)
@PrepareForTest({HttpClients.class, DocumentBuilderFactory.class})
@RunWith(MockitoJUnitRunner.class)
public class IntrospectApiConnectorImplTest {
IntrospectApiConnector introspectApiConnector;
MockedStatic<HttpClients> httpClientsMocked;
MockedStatic<DocumentBuilderFactory> documentBuilderFactoryMocked;
@Before
public void setup() {
VRouter vRouter = mock(VRouter.class);
introspectApiConnector = new IntrospectApiConnectorImpl(vRouter);
PowerMockito.mockStatic(HttpClients.class);
PowerMockito.mockStatic(DocumentBuilderFactory.class);
httpClientsMocked = Mockito.mockStatic(HttpClients.class);
documentBuilderFactoryMocked = Mockito.mockStatic(DocumentBuilderFactory.class);
}
@After
public void tearDown() {
httpClientsMocked.close();
documentBuilderFactoryMocked.close();
}
@Test
@ -66,11 +76,11 @@ public class IntrospectApiConnectorImplTest {
DocumentBuilderFactory documentBuilderFactory = mock(DocumentBuilderFactory.class);
DocumentBuilder documentBuilder = mock(DocumentBuilder.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(httpEntity.getContent()).thenReturn(inputStream);
when(DocumentBuilderFactory.newInstance()).thenReturn(documentBuilderFactory);
documentBuilderFactoryMocked.when(DocumentBuilderFactory::newInstance).thenReturn(documentBuilderFactory);
when(documentBuilderFactory.newDocumentBuilder()).thenReturn(documentBuilder);
when(documentBuilder.parse(any(InputStream.class))).thenReturn(document);
@ -81,7 +91,7 @@ public class IntrospectApiConnectorImplTest {
public void getSnhItfReqWithIOExceptionTest() throws Exception {
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertNull(introspectApiConnector.getSnhItfReq("948f421c-edde-4518-a391-09299cc25dc2"));
@ -95,11 +105,9 @@ public class IntrospectApiConnectorImplTest {
InputStream inputStream = mock(InputStream.class);
DocumentBuilderFactory documentBuilderFactory = mock(DocumentBuilderFactory.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(httpEntity.getContent()).thenReturn(inputStream);
when(DocumentBuilderFactory.newInstance()).thenReturn(documentBuilderFactory);
documentBuilderFactoryMocked.when(DocumentBuilderFactory::newInstance).thenReturn(documentBuilderFactory);
when(documentBuilderFactory.newDocumentBuilder()).thenThrow(ParserConfigurationException.class);
assertNull(introspectApiConnector.getSnhItfReq("948f421c-edde-4518-a391-09299cc25dc2"));
@ -114,11 +122,11 @@ public class IntrospectApiConnectorImplTest {
DocumentBuilderFactory documentBuilderFactory = mock(DocumentBuilderFactory.class);
DocumentBuilder documentBuilder = mock(DocumentBuilder.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(httpEntity.getContent()).thenReturn(inputStream);
when(DocumentBuilderFactory.newInstance()).thenReturn(documentBuilderFactory);
documentBuilderFactoryMocked.when(DocumentBuilderFactory::newInstance).thenReturn(documentBuilderFactory);
when(documentBuilderFactory.newDocumentBuilder()).thenReturn(documentBuilder);
when(documentBuilder.parse(any(InputStream.class))).thenThrow(SAXException.class);

64
plugins/network-elements/tungsten/src/test/java/org/apache/cloudstack/network/tungsten/vrouter/VRouterApiConnectorImplTest.java
View File

@ -28,27 +28,37 @@ import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.junit.After;
import org.junit.Before;
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;
import java.io.IOException;
import java.util.Arrays;
@RunWith(PowerMockRunner.class)
@PrepareForTest({HttpClients.class, EntityUtils.class})
@RunWith(MockitoJUnitRunner.class)
public class VRouterApiConnectorImplTest {
VRouterApiConnector vRouterApiConnector;
MockedStatic<EntityUtils> entityUtilsMocked;
MockedStatic<HttpClients> httpClientsMocked;
@Before
public void setup() {
VRouter vRouter = mock(VRouter.class);
vRouterApiConnector = new VRouterApiConnectorImpl(vRouter);
PowerMockito.mockStatic(HttpClients.class);
PowerMockito.mockStatic(EntityUtils.class);
httpClientsMocked = Mockito.mockStatic(HttpClients.class);
entityUtilsMocked = Mockito.mockStatic(EntityUtils.class);
}
@After
public void tearDown() throws Exception {
httpClientsMocked.close();
entityUtilsMocked.close();
}
@Test
@ -58,10 +68,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
assertTrue(vRouterApiConnector.addPort(port));
}
@ -71,7 +81,7 @@ public class VRouterApiConnectorImplTest {
Port port = mock(Port.class);
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertFalse(vRouterApiConnector.addPort(port));
@ -84,10 +94,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{error:404}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{error:404}");
assertFalse(vRouterApiConnector.addPort(port));
}
@ -98,10 +108,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
assertTrue(vRouterApiConnector.deletePort("948f421c-edde-4518-a391-09299cc25dc2"));
}
@ -110,7 +120,7 @@ public class VRouterApiConnectorImplTest {
public void deletePortWithExceptionTest() throws Exception {
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertFalse(vRouterApiConnector.deletePort("948f421c-edde-4518-a391-09299cc25dc2"));
@ -122,10 +132,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
assertTrue(vRouterApiConnector.enablePort("948f421c-edde-4518-a391-09299cc25dc2"));
}
@ -134,7 +144,7 @@ public class VRouterApiConnectorImplTest {
public void enablePortWithExceptionTest() throws Exception {
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertFalse(vRouterApiConnector.enablePort("948f421c-edde-4518-a391-09299cc25dc2"));
@ -146,10 +156,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
assertTrue(vRouterApiConnector.disablePort("948f421c-edde-4518-a391-09299cc25dc2"));
}
@ -158,7 +168,7 @@ public class VRouterApiConnectorImplTest {
public void disablePortWithExceptionTest() throws Exception {
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertFalse(vRouterApiConnector.disablePort("948f421c-edde-4518-a391-09299cc25dc2"));
@ -172,10 +182,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
assertTrue(vRouterApiConnector.addGateway(Arrays.asList(gateway1, gateway2)));
}
@ -186,7 +196,7 @@ public class VRouterApiConnectorImplTest {
Gateway gateway2 = mock(Gateway.class);
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertFalse(vRouterApiConnector.addGateway(Arrays.asList(gateway1, gateway2)));
@ -200,10 +210,10 @@ public class VRouterApiConnectorImplTest {
CloseableHttpResponse closeableHttpResponse = mock(CloseableHttpResponse.class);
HttpEntity httpEntity = mock(HttpEntity.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenReturn(closeableHttpResponse);
when(closeableHttpResponse.getEntity()).thenReturn(httpEntity);
when(EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
entityUtilsMocked.when(()-> EntityUtils.toString(any(HttpEntity.class))).thenReturn("{}");
assertTrue(vRouterApiConnector.deleteGateway(Arrays.asList(gateway1, gateway2)));
}
@ -214,7 +224,7 @@ public class VRouterApiConnectorImplTest {
Gateway gateway2 = mock(Gateway.class);
CloseableHttpClient httpClient = mock(CloseableHttpClient.class);
when(HttpClients.createDefault()).thenReturn(httpClient);
httpClientsMocked.when(HttpClients::createDefault).thenReturn(httpClient);
when(httpClient.execute(any(HttpUriRequest.class))).thenThrow(IOException.class);
assertFalse(vRouterApiConnector.deleteGateway(Arrays.asList(gateway1, gateway2)));

1
plugins/network-elements/tungsten/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker Normal file
View File

@ -0,0 +1 @@
mock-maker-inline