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

api: remove powermock from tests (#7645)

Browse Source
This commit is contained in:
Vishesh 2023-09-25 13:15:54 +05:30 committed by GitHub
parent c69e3c5f42
commit 9c65767f95
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 248 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
api/src/test/java/org/apache/cloudstack/api/command/admin/account/CreateAccountCmdTest.java
View File

@ -52,9 +52,11 @@ public class CreateAccountCmdTest {
private Integer accountType = 1; private Integer accountType = 1;
private Long domainId = 1L; private Long domainId = 1L;
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
ReflectionTestUtils.setField(createAccountCmd, "domainId", domainId); ReflectionTestUtils.setField(createAccountCmd, "domainId", domainId);
ReflectionTestUtils.setField(createAccountCmd, "accountType", accountType); ReflectionTestUtils.setField(createAccountCmd, "accountType", accountType);
CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class)); CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class));
@ -62,6 +64,7 @@ public class CreateAccountCmdTest {
@After @After
public void tearDown() throws Exception { public void tearDown() throws Exception {
closeable.close();
CallContext.unregister(); CallContext.unregister();
} }

10
api/src/test/java/org/apache/cloudstack/api/command/admin/annotation/AddAnnotationCmdTest.java
View File

@ -18,6 +18,7 @@
*/ */
package org.apache.cloudstack.api.command.admin.annotation; package org.apache.cloudstack.api.command.admin.annotation;
import org.junit.After;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
@ -26,9 +27,16 @@ public class AddAnnotationCmdTest {
private AddAnnotationCmd addAnnotationCmd = new AddAnnotationCmd(); private AddAnnotationCmd addAnnotationCmd = new AddAnnotationCmd();
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
}
@After
public void tearDown() throws Exception {
closeable.close();
} }
@Test (expected = IllegalStateException.class) @Test (expected = IllegalStateException.class)

43
api/src/test/java/org/apache/cloudstack/api/command/admin/systemvm/PatchSystemVMCmdTest.java
View File

@ -20,23 +20,20 @@ import com.cloud.server.ManagementService;
import com.cloud.user.Account; import com.cloud.user.Account;
import com.cloud.utils.Pair; import com.cloud.utils.Pair;
import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PrepareForTest(CallContext.class)
@PowerMockIgnore({"javax.xml.*", "org.w3c.dom.*", "org.apache.xerces.*", "org.xml.*"})
public class PatchSystemVMCmdTest { public class PatchSystemVMCmdTest {
@Mock @Mock
@ -45,9 +42,16 @@ public class PatchSystemVMCmdTest {
@InjectMocks @InjectMocks
PatchSystemVMCmd cmd = new PatchSystemVMCmd(); PatchSystemVMCmd cmd = new PatchSystemVMCmd();
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
}
@After
public void tearDown() throws Exception {
closeable.close();
} }
@Test @Test
@ -76,17 +80,16 @@ public class PatchSystemVMCmdTest {
@Test @Test
public void validateArgsForPatchSystemVMApi() { public void validateArgsForPatchSystemVMApi() {
PowerMockito.mockStatic(CallContext.class); try (MockedStatic<CallContext> callContextMocked = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = PowerMockito.mock(CallContext.class); CallContext callContextMock = Mockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock); callContextMocked.when(CallContext::current).thenReturn(callContextMock);
Account accountMock = PowerMockito.mock(Account.class); Account accountMock = Mockito.mock(Account.class);
PowerMockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock); Mockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock);
Mockito.when(accountMock.getId()).thenReturn(2L); Mockito.when(accountMock.getId()).thenReturn(2L);
ReflectionTestUtils.setField(cmd, "id", 1L); ReflectionTestUtils.setField(cmd, "id", 1L);
Assert.assertEquals((long)cmd.getId(), 1L); Assert.assertEquals((long) cmd.getId(), 1L);
Assert.assertFalse(cmd.isForced()); Assert.assertFalse(cmd.isForced());
Assert.assertEquals(cmd.getEntityOwnerId(), 2L); Assert.assertEquals(cmd.getEntityOwnerId(), 2L);
}
} }
} }

5
api/src/test/java/org/apache/cloudstack/api/command/admin/user/CreateUserCmdTest.java
View File

@ -46,14 +46,17 @@ public class CreateUserCmdTest {
@InjectMocks @InjectMocks
private CreateUserCmd createUserCmd = new CreateUserCmd(); private CreateUserCmd createUserCmd = new CreateUserCmd();
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class)); CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class));
} }
@After @After
public void tearDown() throws Exception { public void tearDown() throws Exception {
closeable.close();
CallContext.unregister(); CallContext.unregister();
} }

48
api/src/test/java/org/apache/cloudstack/api/command/test/ResetVMUserDataCmdTest.java
View File

@ -24,18 +24,17 @@ import org.apache.cloudstack.api.ResponseObject;
import org.apache.cloudstack.api.command.user.vm.ResetVMUserDataCmd; import org.apache.cloudstack.api.command.user.vm.ResetVMUserDataCmd;
import org.apache.cloudstack.api.response.UserVmResponse; import org.apache.cloudstack.api.response.UserVmResponse;
import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
import java.util.ArrayList; import java.util.ArrayList;
@ -45,9 +44,7 @@ import java.util.Map;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PrepareForTest(CallContext.class)
@PowerMockIgnore({"javax.xml.*", "org.w3c.dom.*", "org.apache.xerces.*", "org.xml.*"})
public class ResetVMUserDataCmdTest { public class ResetVMUserDataCmdTest {
@InjectMocks @InjectMocks
@ -66,14 +63,22 @@ public class ResetVMUserDataCmdTest {
private static final long PROJECT_ID = 10L; private static final long PROJECT_ID = 10L;
private static final String ACCOUNT_NAME = "user"; private static final String ACCOUNT_NAME = "user";
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
ReflectionTestUtils.setField(cmd, "accountName", ACCOUNT_NAME); ReflectionTestUtils.setField(cmd, "accountName", ACCOUNT_NAME);
ReflectionTestUtils.setField(cmd, "domainId", DOMAIN_ID); ReflectionTestUtils.setField(cmd, "domainId", DOMAIN_ID);
ReflectionTestUtils.setField(cmd, "projectId", PROJECT_ID); ReflectionTestUtils.setField(cmd, "projectId", PROJECT_ID);
} }
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test @Test
public void testValidResetVMUserDataExecute() { public void testValidResetVMUserDataExecute() {
UserVm result = Mockito.mock(UserVm.class); UserVm result = Mockito.mock(UserVm.class);
@ -95,22 +100,23 @@ public class ResetVMUserDataCmdTest {
@Test @Test
public void validateArgsCmd() { public void validateArgsCmd() {
PowerMockito.mockStatic(CallContext.class); try (MockedStatic<CallContext> callContextMocked = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = PowerMockito.mock(CallContext.class); CallContext callContextMock = Mockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock); callContextMocked.when(CallContext::current).thenReturn(callContextMock);
ReflectionTestUtils.setField(cmd, "id", 1L); ReflectionTestUtils.setField(cmd, "id", 1L);
ReflectionTestUtils.setField(cmd, "userdataId", 2L); ReflectionTestUtils.setField(cmd, "userdataId", 2L);
ReflectionTestUtils.setField(cmd, "userData", "testUserdata"); ReflectionTestUtils.setField(cmd, "userData", "testUserdata");
UserVm vm = Mockito.mock(UserVm.class); UserVm vm = Mockito.mock(UserVm.class);
when(_responseGenerator.findUserVmById(1L)).thenReturn(vm); when(_responseGenerator.findUserVmById(1L)).thenReturn(vm);
when(vm.getAccountId()).thenReturn(200L); when(vm.getAccountId()).thenReturn(200L);
Assert.assertEquals(1L, (long)cmd.getId()); Assert.assertEquals(1L, (long) cmd.getId());
Assert.assertEquals(2L, (long)cmd.getUserdataId()); Assert.assertEquals(2L, (long) cmd.getUserdataId());
Assert.assertEquals("testUserdata", cmd.getUserData()); Assert.assertEquals("testUserdata", cmd.getUserData());
Assert.assertEquals(200L, cmd.getEntityOwnerId()); Assert.assertEquals(200L, cmd.getEntityOwnerId());
}
} }
@Test @Test

149
api/src/test/java/org/apache/cloudstack/api/command/user/firewall/CreateEgressFirewallRuleCmdTest.java
View File

@ -20,29 +20,41 @@ import com.cloud.network.Network;
import com.cloud.network.NetworkService; import com.cloud.network.NetworkService;
import com.cloud.utils.net.NetUtils; import com.cloud.utils.net.NetUtils;
import org.apache.cloudstack.api.ServerApiException; import org.apache.cloudstack.api.ServerApiException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.Spy; import org.mockito.Spy;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PrepareForTest; import org.springframework.test.util.ReflectionTestUtils;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.ArrayList; import java.util.ArrayList;
@PrepareForTest(NetUtils.class) @RunWith(MockitoJUnitRunner.class)
@RunWith(PowerMockRunner.class)
public class CreateEgressFirewallRuleCmdTest { public class CreateEgressFirewallRuleCmdTest {
@Mock @Mock
NetworkService networkServiceMock; NetworkService networkServiceMock;
@Spy @Spy
@InjectMocks
CreateEgressFirewallRuleCmd cmdMock = new CreateEgressFirewallRuleCmd(); CreateEgressFirewallRuleCmd cmdMock = new CreateEgressFirewallRuleCmd();
MockedStatic<NetUtils> netUtilsMocked;
@Before
public void setUp() throws Exception {
ReflectionTestUtils.setField(cmdMock, "_networkService", networkServiceMock);;
netUtilsMocked = Mockito.mockStatic(NetUtils.class);
}
@After
public void tearDown() throws Exception {
netUtilsMocked.close();
}
@Test @Test
public void validateCidrsTestValidCidrs(){ public void validateCidrsTestValidCidrs(){
ArrayList<String> listMock = new ArrayList<>(); ArrayList<String> listMock = new ArrayList<>();
@ -59,10 +71,9 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn(cidrMock).when(networkMock).getCidr(); Mockito.doReturn(cidrMock).when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(cidrMock)).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(cidrMock)).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(cidrMock)).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(cidrMock)).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isNetworkAWithinNetworkB(cidrMock,cidrMock)).thenReturn(true);
PowerMockito.when(NetUtils.isNetworkAWithinNetworkB(cidrMock,cidrMock)).thenReturn(true);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -71,12 +82,9 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class, Mockito.times(2)); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(cidrMock), Mockito.times(2));
NetUtils.isValidIp4Cidr(cidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(cidrMock), Mockito.never());
NetUtils.isValidIp6Cidr(cidrMock); netUtilsMocked.verify(() -> NetUtils.isNetworkAWithinNetworkB(cidrMock,cidrMock), Mockito.times(1));
PowerMockito.verifyStatic(NetUtils.class);
NetUtils.isNetworkAWithinNetworkB(cidrMock,cidrMock);
} }
@Test @Test
@ -95,10 +103,9 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn("10.1.1.0/24").when(networkMock).getCidr(); Mockito.doReturn("10.1.1.0/24").when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(Mockito.eq("10.1.1.0/24"))).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(Mockito.eq("10.1.1.0/24"))).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(Mockito.eq("10.1.1.0/24"))).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(Mockito.eq("10.1.1.0/24"))).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isNetworkAWithinNetworkB(Mockito.eq("10.1.1.0/24"), Mockito.eq("10.1.1.0/24"))).thenReturn(true);
PowerMockito.when(NetUtils.isNetworkAWithinNetworkB(Mockito.eq("10.1.1.0/24"), Mockito.eq("10.1.1.0/24"))).thenReturn(true);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -107,12 +114,10 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class, Mockito.times(2)); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(Mockito.eq("10.1.1.0/24")), Mockito.times(2));
NetUtils.isValidIp4Cidr(Mockito.eq("10.1.1.0/24")); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(Mockito.eq("10.1.1.0/24")), Mockito.never());
NetUtils.isValidIp6Cidr(Mockito.eq("10.1.1.0/24"));
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isNetworkAWithinNetworkB(Mockito.eq("10.1.1.0/24"), Mockito.eq("10.1.1.0/24")));
NetUtils.isNetworkAWithinNetworkB(Mockito.eq("10.1.1.0/24"), Mockito.eq("10.1.1.0/24"));
} }
@Test (expected = ServerApiException.class) @Test (expected = ServerApiException.class)
@ -131,9 +136,8 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn("10.1.1.0/24").when(networkMock).getCidr(); Mockito.doReturn("10.1.1.0/24").when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(sourceCidrMock)).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp4Cidr(sourceCidrMock)).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(sourceCidrMock)).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(sourceCidrMock)).thenReturn(false);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -142,9 +146,8 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class, Mockito.times(1)); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(sourceCidrMock), Mockito.times(1));
NetUtils.isValidIp4Cidr(sourceCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(sourceCidrMock), Mockito.times(1));
NetUtils.isValidIp6Cidr(sourceCidrMock);
} }
@Test (expected = ServerApiException.class) @Test (expected = ServerApiException.class)
@ -167,13 +170,12 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn(sourceCidrMock).when(networkMock).getCidr(); Mockito.doReturn(sourceCidrMock).when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(Mockito.eq(sourceCidrMock))).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(Mockito.eq(sourceCidrMock))).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(Mockito.eq(sourceCidrMock))).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(Mockito.eq(sourceCidrMock))).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock)).thenReturn(true);
PowerMockito.when(NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock)).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(Mockito.eq(destCidrMock))).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(Mockito.eq(destCidrMock))).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(Mockito.eq(destCidrMock))).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(Mockito.eq(destCidrMock))).thenReturn(false);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -182,16 +184,14 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(sourceCidrMock));
NetUtils.isValidIp4Cidr(sourceCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(sourceCidrMock));
NetUtils.isValidIp6Cidr(sourceCidrMock);
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock));
NetUtils.isNetworkAWithinNetworkB(sourceCidrMock,sourceCidrMock);
PowerMockito.verifyStatic(NetUtils.class);
NetUtils.isValidIp4Cidr(destCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(destCidrMock));
NetUtils.isValidIp6Cidr(destCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(destCidrMock));
} }
@Test @Test
@ -214,12 +214,11 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn(sourceCidrMock).when(networkMock).getCidr(); Mockito.doReturn(sourceCidrMock).when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(Mockito.eq(sourceCidrMock))).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(Mockito.eq(sourceCidrMock))).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(Mockito.eq(sourceCidrMock))).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(Mockito.eq(sourceCidrMock))).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp4Cidr(Mockito.eq(destCidrMock))).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(Mockito.eq(destCidrMock))).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp6Cidr(Mockito.eq(destCidrMock))).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(Mockito.eq(destCidrMock))).thenReturn(false);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -228,16 +227,13 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(sourceCidrMock), Mockito.times(1));
NetUtils.isValidIp4Cidr(sourceCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(sourceCidrMock), Mockito.never());
NetUtils.isValidIp6Cidr(sourceCidrMock);
PowerMockito.verifyStatic(NetUtils.class, Mockito.never()); netUtilsMocked.verify(() -> NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock), Mockito.never());
NetUtils.isNetworkAWithinNetworkB(sourceCidrMock,sourceCidrMock);
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(destCidrMock));
NetUtils.isValidIp4Cidr(destCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(destCidrMock), Mockito.never());
NetUtils.isValidIp6Cidr(destCidrMock);
} }
@Test(expected = ServerApiException.class) @Test(expected = ServerApiException.class)
@ -256,10 +252,9 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn(cidrMock).when(networkMock).getCidr(); Mockito.doReturn(cidrMock).when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(cidrMock)).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(cidrMock)).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(cidrMock)).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(cidrMock)).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isNetworkAWithinNetworkB(cidrMock, cidrMock)).thenReturn(false);
PowerMockito.when(NetUtils.isNetworkAWithinNetworkB(cidrMock, cidrMock)).thenReturn(false);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -268,12 +263,10 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class, Mockito.times(1)); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(cidrMock));
NetUtils.isValidIp4Cidr(cidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(cidrMock));
NetUtils.isValidIp6Cidr(cidrMock);
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isNetworkAWithinNetworkB(cidrMock, cidrMock));
NetUtils.isNetworkAWithinNetworkB(cidrMock, cidrMock);
} }
@Test @Test
@ -291,10 +284,9 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.doReturn(sourceCidrMock).when(networkMock).getCidr(); Mockito.doReturn(sourceCidrMock).when(networkMock).getCidr();
PowerMockito.mockStatic(NetUtils.class); netUtilsMocked.when(() -> NetUtils.isValidIp4Cidr(Mockito.eq(sourceCidrMock))).thenReturn(true);
PowerMockito.when(NetUtils.isValidIp4Cidr(Mockito.eq(sourceCidrMock))).thenReturn(true); netUtilsMocked.when(() -> NetUtils.isValidIp6Cidr(Mockito.eq(sourceCidrMock))).thenReturn(false);
PowerMockito.when(NetUtils.isValidIp6Cidr(Mockito.eq(sourceCidrMock))).thenReturn(false); netUtilsMocked.when(() -> NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock)).thenReturn(true);
PowerMockito.when(NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock)).thenReturn(true);
cmdMock.validateCidrs(); cmdMock.validateCidrs();
@ -303,15 +295,12 @@ public class CreateEgressFirewallRuleCmdTest {
Mockito.verify(networkServiceMock).getNetwork(networkIdMock); Mockito.verify(networkServiceMock).getNetwork(networkIdMock);
Mockito.verify(networkMock).getCidr(); Mockito.verify(networkMock).getCidr();
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(sourceCidrMock));
NetUtils.isValidIp4Cidr(sourceCidrMock); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(sourceCidrMock), Mockito.never());
NetUtils.isValidIp6Cidr(sourceCidrMock);
PowerMockito.verifyStatic(NetUtils.class); netUtilsMocked.verify(() -> NetUtils.isNetworkAWithinNetworkB(sourceCidrMock, sourceCidrMock));
NetUtils.isNetworkAWithinNetworkB(sourceCidrMock,sourceCidrMock);
PowerMockito.verifyStatic(NetUtils.class, Mockito.never()); netUtilsMocked.verify(() -> NetUtils.isValidIp4Cidr(null), Mockito.never());
NetUtils.isValidIp4Cidr(null); netUtilsMocked.verify(() -> NetUtils.isValidIp6Cidr(null), Mockito.never());
NetUtils.isValidIp6Cidr(null);
} }
} }

42
api/src/test/java/org/apache/cloudstack/api/command/user/userdata/DeleteUserDataCmdTest.java
View File

@ -22,23 +22,20 @@ import com.cloud.user.AccountService;
import org.apache.cloudstack.api.ServerApiException; import org.apache.cloudstack.api.ServerApiException;
import org.apache.cloudstack.api.response.SuccessResponse; import org.apache.cloudstack.api.response.SuccessResponse;
import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PrepareForTest(CallContext.class)
@PowerMockIgnore({"javax.xml.*", "org.w3c.dom.*", "org.apache.xerces.*", "org.xml.*"})
public class DeleteUserDataCmdTest { public class DeleteUserDataCmdTest {
@InjectMocks @InjectMocks
@ -53,14 +50,21 @@ public class DeleteUserDataCmdTest {
private static final long PROJECT_ID = 10L; private static final long PROJECT_ID = 10L;
private static final String ACCOUNT_NAME = "user"; private static final String ACCOUNT_NAME = "user";
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
ReflectionTestUtils.setField(cmd, "accountName", ACCOUNT_NAME); ReflectionTestUtils.setField(cmd, "accountName", ACCOUNT_NAME);
ReflectionTestUtils.setField(cmd, "domainId", DOMAIN_ID); ReflectionTestUtils.setField(cmd, "domainId", DOMAIN_ID);
ReflectionTestUtils.setField(cmd, "projectId", PROJECT_ID); ReflectionTestUtils.setField(cmd, "projectId", PROJECT_ID);
} }
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test @Test
public void testValidUserDataExecute() { public void testValidUserDataExecute() {
Mockito.doReturn(true).when(_mgr).deleteUserData(cmd); Mockito.doReturn(true).when(_mgr).deleteUserData(cmd);
@ -81,18 +85,18 @@ public class DeleteUserDataCmdTest {
@Test @Test
public void validateArgsCmd() { public void validateArgsCmd() {
PowerMockito.mockStatic(CallContext.class); try (MockedStatic<CallContext> callContextMocked = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = PowerMockito.mock(CallContext.class); CallContext callContextMock = Mockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock); callContextMocked.when(CallContext::current).thenReturn(callContextMock);
Account accountMock = PowerMockito.mock(Account.class); Account accountMock = Mockito.mock(Account.class);
PowerMockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock); Mockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock);
Mockito.when(accountMock.getId()).thenReturn(2L); Mockito.when(accountMock.getId()).thenReturn(2L);
Mockito.doReturn(false).when(_accountService).isAdmin(2L); Mockito.doReturn(false).when(_accountService).isAdmin(2L);
ReflectionTestUtils.setField(cmd, "id", 1L); ReflectionTestUtils.setField(cmd, "id", 1L);
Assert.assertEquals(1L, (long)cmd.getId()); Assert.assertEquals(1L, (long) cmd.getId());
Assert.assertEquals(2L, cmd.getEntityOwnerId()); Assert.assertEquals(2L, cmd.getEntityOwnerId());
}
} }
} }

45
api/src/test/java/org/apache/cloudstack/api/command/user/userdata/LinkUserDataToTemplateCmdTest.java
View File

@ -20,29 +20,25 @@ package org.apache.cloudstack.api.command.user.userdata;
import com.cloud.storage.Storage; import com.cloud.storage.Storage;
import com.cloud.template.TemplateApiService; import com.cloud.template.TemplateApiService;
import com.cloud.template.VirtualMachineTemplate; import com.cloud.template.VirtualMachineTemplate;
import com.cloud.user.Account;
import com.cloud.user.UserData; import com.cloud.user.UserData;
import com.cloud.utils.db.EntityManager; import com.cloud.utils.db.EntityManager;
import org.apache.cloudstack.api.ResponseGenerator; import org.apache.cloudstack.api.ResponseGenerator;
import org.apache.cloudstack.api.response.TemplateResponse; import org.apache.cloudstack.api.response.TemplateResponse;
import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PrepareForTest(CallContext.class)
@PowerMockIgnore({"javax.xml.*", "org.w3c.dom.*", "org.apache.xerces.*", "org.xml.*"})
public class LinkUserDataToTemplateCmdTest { public class LinkUserDataToTemplateCmdTest {
@Mock @Mock
@ -60,9 +56,16 @@ public class LinkUserDataToTemplateCmdTest {
@Mock @Mock
VirtualMachineTemplate virtualMachineTemplate; VirtualMachineTemplate virtualMachineTemplate;
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
}
@After
public void tearDown() throws Exception {
closeable.close();
} }
@Test @Test
@ -84,21 +87,19 @@ public class LinkUserDataToTemplateCmdTest {
@Test @Test
public void validateArgsCmd() { public void validateArgsCmd() {
PowerMockito.mockStatic(CallContext.class); try (MockedStatic<CallContext> callContextMocked = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = PowerMockito.mock(CallContext.class); CallContext callContextMock = Mockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock); callContextMocked.when(CallContext::current).thenReturn(callContextMock);
Account accountMock = PowerMockito.mock(Account.class); ReflectionTestUtils.setField(cmd, "templateId", 1L);
PowerMockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock); ReflectionTestUtils.setField(cmd, "userdataId", 3L);
Mockito.when(accountMock.getId()).thenReturn(2L);
ReflectionTestUtils.setField(cmd, "templateId", 1L);
ReflectionTestUtils.setField(cmd, "userdataId", 3L);
Mockito.doReturn(virtualMachineTemplate).when(_entityMgr).findById(VirtualMachineTemplate.class, cmd.getTemplateId()); Mockito.doReturn(virtualMachineTemplate).when(_entityMgr).findById(VirtualMachineTemplate.class, cmd.getTemplateId());
PowerMockito.when(virtualMachineTemplate.getAccountId()).thenReturn(1L); Mockito.when(virtualMachineTemplate.getAccountId()).thenReturn(1L);
Assert.assertEquals(1L, (long)cmd.getTemplateId()); Assert.assertEquals(1L, (long) cmd.getTemplateId());
Assert.assertEquals(3L, (long)cmd.getUserdataId()); Assert.assertEquals(3L, (long) cmd.getUserdataId());
Assert.assertEquals(1L, cmd.getEntityOwnerId()); Assert.assertEquals(1L, cmd.getEntityOwnerId());
}
} }
@Test @Test

19
api/src/test/java/org/apache/cloudstack/api/command/user/userdata/ListUserDataCmdTest.java
View File

@ -20,10 +20,10 @@ import com.cloud.server.ManagementService;
import com.cloud.user.UserData; import com.cloud.user.UserData;
import com.cloud.utils.Pair; import com.cloud.utils.Pair;
import org.apache.cloudstack.api.response.ListResponse; import org.apache.cloudstack.api.response.ListResponse;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.apache.cloudstack.api.ResponseGenerator; import org.apache.cloudstack.api.ResponseGenerator;
import org.apache.cloudstack.api.response.UserDataResponse; import org.apache.cloudstack.api.response.UserDataResponse;
import org.apache.cloudstack.context.CallContext;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
@ -31,16 +31,12 @@ import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.powermock.core.classloader.annotations.PowerMockIgnore; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PrepareForTest(CallContext.class)
@PowerMockIgnore({"javax.xml.*", "org.w3c.dom.*", "org.apache.xerces.*", "org.xml.*"})
public class ListUserDataCmdTest { public class ListUserDataCmdTest {
@InjectMocks @InjectMocks
@ -52,9 +48,16 @@ public class ListUserDataCmdTest {
@Mock @Mock
ResponseGenerator _responseGenerator; ResponseGenerator _responseGenerator;
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
}
@After
public void tearDown() throws Exception {
closeable.close();
} }
@Test @Test

44
api/src/test/java/org/apache/cloudstack/api/command/user/userdata/RegisterUserDataCmdTest.java
View File

@ -18,31 +18,27 @@ package org.apache.cloudstack.api.command.user.userdata;
import com.cloud.exception.InvalidParameterValueException; import com.cloud.exception.InvalidParameterValueException;
import com.cloud.server.ManagementService; import com.cloud.server.ManagementService;
import com.cloud.user.Account;
import com.cloud.user.AccountService; import com.cloud.user.AccountService;
import com.cloud.user.UserData; import com.cloud.user.UserData;
import org.apache.cloudstack.api.ResponseGenerator; import org.apache.cloudstack.api.ResponseGenerator;
import org.apache.cloudstack.api.response.UserDataResponse; import org.apache.cloudstack.api.response.UserDataResponse;
import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.context.CallContext;
import org.junit.After;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PrepareForTest(CallContext.class)
@PowerMockIgnore({"javax.xml.*", "org.w3c.dom.*", "org.apache.xerces.*", "org.xml.*"})
public class RegisterUserDataCmdTest { public class RegisterUserDataCmdTest {
@InjectMocks @InjectMocks
@ -61,14 +57,22 @@ public class RegisterUserDataCmdTest {
private static final long PROJECT_ID = 10L; private static final long PROJECT_ID = 10L;
private static final String ACCOUNT_NAME = "user"; private static final String ACCOUNT_NAME = "user";
private AutoCloseable closeable;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); closeable = MockitoAnnotations.openMocks(this);
ReflectionTestUtils.setField(cmd, "accountName", ACCOUNT_NAME); ReflectionTestUtils.setField(cmd, "accountName", ACCOUNT_NAME);
ReflectionTestUtils.setField(cmd, "domainId", DOMAIN_ID); ReflectionTestUtils.setField(cmd, "domainId", DOMAIN_ID);
ReflectionTestUtils.setField(cmd, "projectId", PROJECT_ID); ReflectionTestUtils.setField(cmd, "projectId", PROJECT_ID);
} }
@After
public void tearDown() throws Exception {
closeable.close();
}
@Test @Test
public void testValidUserDataExecute() { public void testValidUserDataExecute() {
UserData result = Mockito.mock(UserData.class); UserData result = Mockito.mock(UserData.class);
@ -87,20 +91,18 @@ public class RegisterUserDataCmdTest {
@Test @Test
public void validateArgsCmd() { public void validateArgsCmd() {
PowerMockito.mockStatic(CallContext.class); try (MockedStatic<CallContext> callContextMocked = Mockito.mockStatic(CallContext.class)) {
CallContext callContextMock = PowerMockito.mock(CallContext.class); CallContext callContextMock = Mockito.mock(CallContext.class);
PowerMockito.when(CallContext.current()).thenReturn(callContextMock); callContextMocked.when(CallContext::current).thenReturn(callContextMock);
Account accountMock = PowerMockito.mock(Account.class); ReflectionTestUtils.setField(cmd, "name", "testUserdataName");
PowerMockito.when(callContextMock.getCallingAccount()).thenReturn(accountMock); ReflectionTestUtils.setField(cmd, "userData", "testUserdata");
Mockito.when(accountMock.getId()).thenReturn(2L);
ReflectionTestUtils.setField(cmd, "name", "testUserdataName");
ReflectionTestUtils.setField(cmd, "userData", "testUserdata");
when(_accountService.finalyzeAccountId(ACCOUNT_NAME, DOMAIN_ID, PROJECT_ID, true)).thenReturn(200L); when(_accountService.finalyzeAccountId(ACCOUNT_NAME, DOMAIN_ID, PROJECT_ID, true)).thenReturn(200L);
Assert.assertEquals("testUserdataName", cmd.getName()); Assert.assertEquals("testUserdataName", cmd.getName());
Assert.assertEquals("testUserdata", cmd.getUserData()); Assert.assertEquals("testUserdata", cmd.getUserData());
Assert.assertEquals(200L, cmd.getEntityOwnerId()); Assert.assertEquals(200L, cmd.getEntityOwnerId());
}
} }
@Test(expected = InvalidParameterValueException.class) @Test(expected = InvalidParameterValueException.class)

32
api/src/test/java/org/apache/cloudstack/api/command/user/vpc/CreateVPCCmdTest.java
View File

@ -30,14 +30,15 @@ import org.apache.cloudstack.api.ResponseGenerator;
import org.apache.cloudstack.api.ResponseObject; import org.apache.cloudstack.api.ResponseObject;
import org.apache.cloudstack.api.response.VpcResponse; import org.apache.cloudstack.api.response.VpcResponse;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.modules.junit4.PowerMockRunner; import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
public class CreateVPCCmdTest extends TestCase { public class CreateVPCCmdTest extends TestCase {
@Mock @Mock
@ -48,97 +49,107 @@ public class CreateVPCCmdTest extends TestCase {
public AccountService _accountService; public AccountService _accountService;
private ResponseGenerator responseGenerator; private ResponseGenerator responseGenerator;
@InjectMocks @InjectMocks
CreateVPCCmd cmd = new CreateVPCCmd() { CreateVPCCmd cmd = new CreateVPCCmd();
@Override
public Long getEntityId() {
return 2L;
}
};
@Test
public void testGetAccountName() { public void testGetAccountName() {
String accountName = "admin"; String accountName = "admin";
ReflectionTestUtils.setField(cmd, "accountName", accountName); ReflectionTestUtils.setField(cmd, "accountName", accountName);
Assert.assertEquals(cmd.getAccountName(), accountName); Assert.assertEquals(cmd.getAccountName(), accountName);
} }
@Test
public void testGetDomainId() { public void testGetDomainId() {
Long domainId = 1L; Long domainId = 1L;
ReflectionTestUtils.setField(cmd, "domainId", domainId); ReflectionTestUtils.setField(cmd, "domainId", domainId);
Assert.assertEquals(cmd.getDomainId(), domainId); Assert.assertEquals(cmd.getDomainId(), domainId);
} }
@Test
public void testGetZoneId() { public void testGetZoneId() {
Long zoneId = 1L; Long zoneId = 1L;
ReflectionTestUtils.setField(cmd, "zoneId", zoneId); ReflectionTestUtils.setField(cmd, "zoneId", zoneId);
Assert.assertEquals(cmd.getZoneId(), zoneId); Assert.assertEquals(cmd.getZoneId(), zoneId);
} }
@Test
public void testGetVpcName() { public void testGetVpcName() {
String vpcName = "vpcNet"; String vpcName = "vpcNet";
ReflectionTestUtils.setField(cmd, "vpcName", vpcName); ReflectionTestUtils.setField(cmd, "vpcName", vpcName);
Assert.assertEquals(cmd.getVpcName(), vpcName); Assert.assertEquals(cmd.getVpcName(), vpcName);
} }
@Test
public void testGetCidr() { public void testGetCidr() {
String cidr = "10.0.0.0/8"; String cidr = "10.0.0.0/8";
ReflectionTestUtils.setField(cmd, "cidr", cidr); ReflectionTestUtils.setField(cmd, "cidr", cidr);
Assert.assertEquals(cmd.getCidr(), cidr); Assert.assertEquals(cmd.getCidr(), cidr);
} }
@Test
public void testGetDisplayText() { public void testGetDisplayText() {
String displayText = "VPC Network"; String displayText = "VPC Network";
ReflectionTestUtils.setField(cmd, "displayText", displayText); ReflectionTestUtils.setField(cmd, "displayText", displayText);
Assert.assertEquals(cmd.getDisplayText(), displayText); Assert.assertEquals(cmd.getDisplayText(), displayText);
} }
@Test
public void testGetVpcOffering() { public void testGetVpcOffering() {
Long vpcOffering = 1L; Long vpcOffering = 1L;
ReflectionTestUtils.setField(cmd, "vpcOffering", vpcOffering); ReflectionTestUtils.setField(cmd, "vpcOffering", vpcOffering);
Assert.assertEquals(cmd.getVpcOffering(), vpcOffering); Assert.assertEquals(cmd.getVpcOffering(), vpcOffering);
} }
@Test
public void testGetNetworkDomain() { public void testGetNetworkDomain() {
String netDomain = "cs1cloud.internal"; String netDomain = "cs1cloud.internal";
ReflectionTestUtils.setField(cmd, "networkDomain", netDomain); ReflectionTestUtils.setField(cmd, "networkDomain", netDomain);
Assert.assertEquals(cmd.getNetworkDomain(), netDomain); Assert.assertEquals(cmd.getNetworkDomain(), netDomain);
} }
@Test
public void testGetPublicMtuWhenNotSet() { public void testGetPublicMtuWhenNotSet() {
Integer publicMtu = null; Integer publicMtu = null;
ReflectionTestUtils.setField(cmd, "publicMtu", publicMtu); ReflectionTestUtils.setField(cmd, "publicMtu", publicMtu);
Assert.assertEquals(NetworkService.DEFAULT_MTU, cmd.getPublicMtu()); Assert.assertEquals(NetworkService.DEFAULT_MTU, cmd.getPublicMtu());
} }
@Test
public void testGetPublicMtuWhenSet() { public void testGetPublicMtuWhenSet() {
Integer publicMtu = 1450; Integer publicMtu = 1450;
ReflectionTestUtils.setField(cmd, "publicMtu", publicMtu); ReflectionTestUtils.setField(cmd, "publicMtu", publicMtu);
Assert.assertEquals(cmd.getPublicMtu(), publicMtu); Assert.assertEquals(cmd.getPublicMtu(), publicMtu);
} }
@Test
public void testIsStartWhenNull() { public void testIsStartWhenNull() {
Boolean start = null; Boolean start = null;
ReflectionTestUtils.setField(cmd, "start", start); ReflectionTestUtils.setField(cmd, "start", start);
Assert.assertTrue(cmd.isStart()); Assert.assertTrue(cmd.isStart());
} }
@Test
public void testIsStartWhenValidValuePassed() { public void testIsStartWhenValidValuePassed() {
Boolean start = true; Boolean start = true;
ReflectionTestUtils.setField(cmd, "start", start); ReflectionTestUtils.setField(cmd, "start", start);
Assert.assertTrue(cmd.isStart()); Assert.assertTrue(cmd.isStart());
} }
@Test
public void testGetDisplayVpc() { public void testGetDisplayVpc() {
Boolean display = true; Boolean display = true;
ReflectionTestUtils.setField(cmd, "display", display); ReflectionTestUtils.setField(cmd, "display", display);
Assert.assertTrue(cmd.getDisplayVpc()); Assert.assertTrue(cmd.getDisplayVpc());
} }
@Test
public void testGetDisplayTextWhenEmpty() { public void testGetDisplayTextWhenEmpty() {
String netName = "net-vpc"; String netName = "net-vpc";
ReflectionTestUtils.setField(cmd, "vpcName", netName); ReflectionTestUtils.setField(cmd, "vpcName", netName);
Assert.assertEquals(cmd.getDisplayText(), netName); Assert.assertEquals(cmd.getDisplayText(), netName);
} }
@Test
public void testCreate() throws ResourceAllocationException { public void testCreate() throws ResourceAllocationException {
Vpc vpc = Mockito.mock(Vpc.class); Vpc vpc = Mockito.mock(Vpc.class);
ReflectionTestUtils.setField(cmd, "zoneId", 1L); ReflectionTestUtils.setField(cmd, "zoneId", 1L);
@ -149,17 +160,18 @@ public class CreateVPCCmdTest extends TestCase {
ReflectionTestUtils.setField(cmd, "networkDomain", "cs1cloud.internal"); ReflectionTestUtils.setField(cmd, "networkDomain", "cs1cloud.internal");
ReflectionTestUtils.setField(cmd, "display", true); ReflectionTestUtils.setField(cmd, "display", true);
ReflectionTestUtils.setField(cmd, "publicMtu", 1450); ReflectionTestUtils.setField(cmd, "publicMtu", 1450);
Mockito.when(_accountService.finalyzeAccountId(Mockito.anyString(), Mockito.anyLong(), Mockito.anyLong(), Mockito.anyBoolean())).thenReturn(1L);
Mockito.when(cmd.getEntityOwnerId()).thenReturn(1L);
Mockito.when(_vpcService.createVpc(Mockito.any(CreateVPCCmd.class))).thenReturn(vpc); Mockito.when(_vpcService.createVpc(Mockito.any(CreateVPCCmd.class))).thenReturn(vpc);
cmd.create(); cmd.create();
Mockito.verify(_vpcService, Mockito.times(1)).createVpc(Mockito.any(CreateVPCCmd.class)); Mockito.verify(_vpcService, Mockito.times(1)).createVpc(Mockito.any(CreateVPCCmd.class));
} }
@Test
public void testExecute() throws ResourceUnavailableException, InsufficientCapacityException { public void testExecute() throws ResourceUnavailableException, InsufficientCapacityException {
ReflectionTestUtils.setField(cmd, "start", true); ReflectionTestUtils.setField(cmd, "start", true);
Vpc vpc = Mockito.mock(Vpc.class); Vpc vpc = Mockito.mock(Vpc.class);
VpcResponse response = Mockito.mock(VpcResponse.class); VpcResponse response = Mockito.mock(VpcResponse.class);
ReflectionTestUtils.setField(cmd, "id", 1L);
responseGenerator = Mockito.mock(ResponseGenerator.class); responseGenerator = Mockito.mock(ResponseGenerator.class);
Mockito.when(_vpcService.startVpc(1L, true)).thenReturn(true); Mockito.when(_vpcService.startVpc(1L, true)).thenReturn(true);
Mockito.when(_entityMgr.findById(Mockito.eq(Vpc.class), Mockito.any(Long.class))).thenReturn(vpc); Mockito.when(_entityMgr.findById(Mockito.eq(Vpc.class), Mockito.any(Long.class))).thenReturn(vpc);

15
api/src/test/java/org/apache/cloudstack/api/command/user/vpc/UpdateVPCCmdTest.java
View File

@ -23,17 +23,17 @@ import com.cloud.network.vpc.Vpc;
import com.cloud.network.vpc.VpcService; import com.cloud.network.vpc.VpcService;
import junit.framework.TestCase; import junit.framework.TestCase;
import org.apache.cloudstack.api.ResponseGenerator; import org.apache.cloudstack.api.ResponseGenerator;
import org.apache.cloudstack.api.ResponseObject;
import org.apache.cloudstack.api.response.VpcResponse; import org.apache.cloudstack.api.response.VpcResponse;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.modules.junit4.PowerMockRunner; import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
public class UpdateVPCCmdTest extends TestCase { public class UpdateVPCCmdTest extends TestCase {
@Mock @Mock
@ -44,36 +44,42 @@ public class UpdateVPCCmdTest extends TestCase {
@InjectMocks @InjectMocks
UpdateVPCCmd cmd = new UpdateVPCCmd(); UpdateVPCCmd cmd = new UpdateVPCCmd();
@Test
public void testGetVpcName() { public void testGetVpcName() {
String vpcName = "updatedVpcName"; String vpcName = "updatedVpcName";
ReflectionTestUtils.setField(cmd, "vpcName", vpcName); ReflectionTestUtils.setField(cmd, "vpcName", vpcName);
Assert.assertEquals(cmd.getVpcName(), vpcName); Assert.assertEquals(cmd.getVpcName(), vpcName);
} }
@Test
public void testGetDisplayText() { public void testGetDisplayText() {
String displayText = "Updated VPC Name"; String displayText = "Updated VPC Name";
ReflectionTestUtils.setField(cmd, "displayText", displayText); ReflectionTestUtils.setField(cmd, "displayText", displayText);
Assert.assertEquals(cmd.getDisplayText(), displayText); Assert.assertEquals(cmd.getDisplayText(), displayText);
} }
@Test
public void testGetId() { public void testGetId() {
Long id = 1L; Long id = 1L;
ReflectionTestUtils.setField(cmd, "id", id); ReflectionTestUtils.setField(cmd, "id", id);
Assert.assertEquals(cmd.getId(), id); Assert.assertEquals(cmd.getId(), id);
} }
@Test
public void testIsDisplayVpc() { public void testIsDisplayVpc() {
Boolean display = true; Boolean display = true;
ReflectionTestUtils.setField(cmd, "display", display); ReflectionTestUtils.setField(cmd, "display", display);
Assert.assertEquals(cmd.isDisplayVpc(), display); Assert.assertEquals(cmd.isDisplayVpc(), display);
} }
@Test
public void testGetPublicMtu() { public void testGetPublicMtu() {
Integer publicMtu = 1450; Integer publicMtu = 1450;
ReflectionTestUtils.setField(cmd, "publicMtu", publicMtu); ReflectionTestUtils.setField(cmd, "publicMtu", publicMtu);
Assert.assertEquals(cmd.getPublicMtu(), publicMtu); Assert.assertEquals(cmd.getPublicMtu(), publicMtu);
} }
@Test
public void testExecute() throws ResourceUnavailableException, InsufficientCapacityException { public void testExecute() throws ResourceUnavailableException, InsufficientCapacityException {
ReflectionTestUtils.setField(cmd, "id", 1L); ReflectionTestUtils.setField(cmd, "id", 1L);
ReflectionTestUtils.setField(cmd, "vpcName", "updatedVpcName"); ReflectionTestUtils.setField(cmd, "vpcName", "updatedVpcName");
@ -86,9 +92,6 @@ public class UpdateVPCCmdTest extends TestCase {
VpcResponse response = Mockito.mock(VpcResponse.class); VpcResponse response = Mockito.mock(VpcResponse.class);
responseGenerator = Mockito.mock(ResponseGenerator.class); responseGenerator = Mockito.mock(ResponseGenerator.class);
cmd._responseGenerator = responseGenerator; cmd._responseGenerator = responseGenerator;
Mockito.when(_vpcService.updateVpc(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(),
Mockito.anyString(), Mockito.anyBoolean(), Mockito.anyInt(), Mockito.anyString())).thenReturn(vpc);
Mockito.when(responseGenerator.createVpcResponse(ResponseObject.ResponseView.Full, vpc)).thenReturn(response);
Mockito.verify(_vpcService, Mockito.times(0)).updateVpc(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.verify(_vpcService, Mockito.times(0)).updateVpc(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(),
Mockito.anyString(), Mockito.anyBoolean(), Mockito.anyInt(), Mockito.anyString()); Mockito.anyString(), Mockito.anyBoolean(), Mockito.anyInt(), Mockito.anyString());

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

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