| // Licensed to the Apache Software Foundation (ASF) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The ASF licenses this file | |
| // to you under the Apache License, Version 2.0 (the | |
| // "License"); you may not use this file except in compliance | |
| // with the License. You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, | |
| // software distributed under the License is distributed on an | |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| // KIND, either express or implied. See the License for the | |
| // specific language governing permissions and limitations | |
| // under the License. | |
| package com.cloud.api; | |
| import java.lang.reflect.Field; | |
| import java.text.ParseException; | |
| import java.text.SimpleDateFormat; | |
| import java.util.Arrays; | |
| import java.util.Collections; | |
| import java.util.Date; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import java.util.TimeZone; | |
| import java.util.UUID; | |
| import org.junit.After; | |
| import org.junit.Assert; | |
| import org.junit.Before; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| import org.mockito.InjectMocks; | |
| import org.mockito.Mock; | |
| import org.mockito.MockedStatic; | |
| import org.mockito.Mockito; | |
| import org.mockito.Spy; | |
| import org.mockito.junit.MockitoJUnitRunner; | |
| import org.springframework.test.util.ReflectionTestUtils; | |
| import org.apache.cloudstack.annotation.dao.AnnotationDao; | |
| import org.apache.cloudstack.api.ResponseObject; | |
| import org.apache.cloudstack.api.response.AutoScaleVmGroupResponse; | |
| import org.apache.cloudstack.api.response.AutoScaleVmProfileResponse; | |
| import org.apache.cloudstack.api.response.ConsoleSessionResponse; | |
| import org.apache.cloudstack.api.response.DirectDownloadCertificateResponse; | |
| import org.apache.cloudstack.api.response.GuestOSCategoryResponse; | |
| import org.apache.cloudstack.api.response.IpQuarantineResponse; | |
| import org.apache.cloudstack.api.response.NicSecondaryIpResponse; | |
| import org.apache.cloudstack.api.response.ResourceIconResponse; | |
| import org.apache.cloudstack.api.response.TemplateResponse; | |
| import org.apache.cloudstack.api.response.UnmanagedInstanceResponse; | |
| import org.apache.cloudstack.api.response.UsageRecordResponse; | |
| import org.apache.cloudstack.api.response.TrafficTypeResponse; | |
| import org.apache.cloudstack.context.CallContext; | |
| import org.apache.cloudstack.usage.UsageService; | |
| import org.apache.cloudstack.vm.UnmanagedInstanceTO; | |
| import com.cloud.capacity.Capacity; | |
| import com.cloud.configuration.Resource; | |
| import com.cloud.domain.DomainVO; | |
| import com.cloud.host.HostVO; | |
| import com.cloud.network.Networks; | |
| import com.cloud.network.PhysicalNetworkTrafficType; | |
| import com.cloud.network.PublicIpQuarantine; | |
| import com.cloud.network.as.AutoScaleVmGroup; | |
| import com.cloud.network.as.AutoScaleVmGroupVO; | |
| import com.cloud.network.as.AutoScaleVmProfileVO; | |
| import com.cloud.network.as.dao.AutoScaleVmGroupVmMapDao; | |
| import com.cloud.network.dao.IPAddressDao; | |
| import com.cloud.network.dao.IPAddressVO; | |
| import com.cloud.network.dao.LoadBalancerVO; | |
| import com.cloud.network.dao.NetworkServiceMapDao; | |
| import com.cloud.network.dao.NetworkVO; | |
| import com.cloud.network.dao.PhysicalNetworkVO; | |
| import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO; | |
| import com.cloud.resource.icon.ResourceIconVO; | |
| import com.cloud.server.ResourceIcon; | |
| import com.cloud.server.ResourceIconManager; | |
| import com.cloud.server.ResourceTag; | |
| import com.cloud.storage.GuestOsCategory; | |
| import com.cloud.storage.VMTemplateVO; | |
| import com.cloud.usage.UsageVO; | |
| import com.cloud.user.Account; | |
| import com.cloud.user.AccountManager; | |
| import com.cloud.user.AccountVO; | |
| import com.cloud.user.User; | |
| import com.cloud.user.UserData; | |
| import com.cloud.user.UserDataVO; | |
| import com.cloud.user.UserVO; | |
| import com.cloud.user.dao.UserDataDao; | |
| import com.cloud.utils.net.Ip; | |
| import com.cloud.vm.ConsoleSessionVO; | |
| import com.cloud.vm.NicSecondaryIp; | |
| import com.cloud.vm.VMInstanceVO; | |
| import static org.junit.Assert.assertEquals; | |
| import static org.junit.Assert.assertFalse; | |
| import static org.junit.Assert.assertNull; | |
| import static org.junit.Assert.assertTrue; | |
| import static org.mockito.ArgumentMatchers.any; | |
| import static org.mockito.ArgumentMatchers.anyLong; | |
| import static org.mockito.Mockito.verify; | |
| import static org.mockito.Mockito.when; | |
| @RunWith(MockitoJUnitRunner.class) | |
| public class ApiResponseHelperTest { | |
| @Mock | |
| UsageService usageService; | |
| ApiResponseHelper helper; | |
| @Mock | |
| AccountManager accountManagerMock; | |
| @Mock | |
| AnnotationDao annotationDaoMock; | |
| @Mock | |
| NetworkServiceMapDao ntwkSrvcDaoMock; | |
| @Mock | |
| AutoScaleVmGroupVmMapDao autoScaleVmGroupVmMapDaoMock; | |
| @Mock | |
| UserDataDao userDataDaoMock; | |
| @Mock | |
| IPAddressDao ipAddressDaoMock; | |
| @Mock | |
| ResourceIconManager resourceIconManager; | |
| @Mock | |
| private ConsoleSessionVO consoleSessionMock; | |
| @Mock | |
| private DomainVO domainVOMock; | |
| @Mock | |
| private UserVO userVOMock; | |
| @Mock | |
| private AccountVO accountVOMock; | |
| @Mock | |
| private HostVO hostVOMock; | |
| @Mock | |
| private VMInstanceVO vmInstanceVOMock; | |
| @Spy | |
| @InjectMocks | |
| ApiResponseHelper apiResponseHelper = new ApiResponseHelper(); | |
| SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss ZZZ"); | |
| static long zoneId = 1L; | |
| static long domainId = 2L; | |
| static long accountId = 3L; | |
| static long serviceOfferingId = 4L; | |
| static long templateId = 5L; | |
| static String userdata = "userdata"; | |
| static long userdataId = 6L; | |
| static String userdataDetails = "userdataDetails"; | |
| static String userdataNew = "userdataNew"; | |
| static long autoScaleUserId = 7L; | |
| @Before | |
| public void injectMocks() throws SecurityException, NoSuchFieldException, | |
| IllegalArgumentException, IllegalAccessException { | |
| Field usageSvcField = ApiResponseHelper.class | |
| .getDeclaredField("_usageSvc"); | |
| usageSvcField.setAccessible(true); | |
| helper = new ApiResponseHelper(); | |
| usageSvcField.set(helper, usageService); | |
| } | |
| @Before | |
| public void setup() { | |
| AccountVO account = new AccountVO("testaccount", 1L, "networkdomain", Account.Type.NORMAL, "uuid"); | |
| account.setId(1); | |
| UserVO user = new UserVO(1, "testuser", "password", "firstname", "lastName", "email", "timezone", | |
| UUID.randomUUID().toString(), User.Source.UNKNOWN); | |
| CallContext.register(user, account); | |
| } | |
| @After | |
| public void cleanup() { | |
| CallContext.unregister(); | |
| } | |
| @Test | |
| public void getDateStringInternal() throws ParseException { | |
| Mockito.when(usageService.getUsageTimezone()).thenReturn( | |
| TimeZone.getTimeZone("UTC")); | |
| assertEquals("2014-06-29'T'23:45:00+00:00", helper | |
| .getDateStringInternal(dateFormat.parse("2014-06-29 23:45:00 UTC"))); | |
| assertEquals("2014-06-29'T'23:45:01+00:00", helper | |
| .getDateStringInternal(dateFormat.parse("2014-06-29 23:45:01 UTC"))); | |
| assertEquals("2014-06-29'T'23:45:11+00:00", helper | |
| .getDateStringInternal(dateFormat.parse("2014-06-29 23:45:11 UTC"))); | |
| assertEquals("2014-06-29'T'23:05:11+00:00", helper | |
| .getDateStringInternal(dateFormat.parse("2014-06-29 23:05:11 UTC"))); | |
| assertEquals("2014-05-29'T'08:45:11+00:00", helper | |
| .getDateStringInternal(dateFormat.parse("2014-05-29 08:45:11 UTC"))); | |
| } | |
| @Test | |
| public void testUsageRecordResponse(){ | |
| //Creating the usageVO object to be passed to the createUsageResponse. | |
| Long zoneId = null; | |
| Long accountId = 1L; | |
| Long domainId = 1L; | |
| String Description = "Test Object"; | |
| String usageDisplay = " "; | |
| int usageType = -1; | |
| Double rawUsage = null; | |
| Long vmId = null; | |
| String vmName = " "; | |
| Long offeringId = null; | |
| Long templateId = null; | |
| Long usageId = null; | |
| Date startDate = null; | |
| Date endDate = null; | |
| String type = " "; | |
| UsageVO usage = new UsageVO(zoneId,accountId,domainId,Description,usageDisplay,usageType,rawUsage,vmId,vmName,offeringId,templateId,usageId,startDate,endDate,type); | |
| DomainVO domain = new DomainVO(); | |
| domain.setName("DomainName"); | |
| AccountVO account = new AccountVO(); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.findAccountById(anyLong())).thenReturn(account); | |
| when(ApiDBUtils.findDomainById(anyLong())).thenReturn(domain); | |
| UsageRecordResponse MockResponse = helper.createUsageResponse(usage); | |
| assertEquals("DomainName", MockResponse.getDomainName()); | |
| } | |
| } | |
| @Test | |
| public void setResponseIpAddressTestIpv4() { | |
| NicSecondaryIp result = Mockito.mock(NicSecondaryIp.class); | |
| NicSecondaryIpResponse response = new NicSecondaryIpResponse(); | |
| setResult(result, "ipv4", "ipv6"); | |
| ApiResponseHelper.setResponseIpAddress(result, response); | |
| assertTrue(response.getIpAddr().equals("ipv4")); | |
| } | |
| private void setResult(NicSecondaryIp result, String ipv4, String ipv6) { | |
| when(result.getIp4Address()).thenReturn(ipv4); | |
| when(result.getIp6Address()).thenReturn(ipv6); | |
| } | |
| @Test | |
| public void setResponseIpAddressTestIpv6() { | |
| NicSecondaryIp result = Mockito.mock(NicSecondaryIp.class); | |
| NicSecondaryIpResponse response = new NicSecondaryIpResponse(); | |
| setResult(result, null, "ipv6"); | |
| ApiResponseHelper.setResponseIpAddress(result, response); | |
| assertTrue(response.getIpAddr().equals("ipv6")); | |
| } | |
| @Test | |
| public void testHandleCertificateResponse() { | |
| String certStr = "-----BEGIN CERTIFICATE-----\n" + | |
| "MIIGLTCCBRWgAwIBAgIQOHZRhOAYLowYNcopBvxCdjANBgkqhkiG9w0BAQsFADCB\n" + | |
| "jzELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G\n" + | |
| "A1UEBxMHU2FsZm9yZDEYMBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTcwNQYDVQQD\n" + | |
| "Ey5TZWN0aWdvIFJTQSBEb21haW4gVmFsaWRhdGlvbiBTZWN1cmUgU2VydmVyIENB\n" + | |
| "MB4XDTIxMDYxNTAwMDAwMFoXDTIyMDcxNjIzNTk1OVowFzEVMBMGA1UEAwwMKi5h\n" + | |
| "cGFjaGUub3JnMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4UoHCmK5\n" + | |
| "XdbyZ++d2BGuX35zZcESvr4K1Hw7ZTbyzMC+uokBKJcng1Hf5ctjUFKCoz7AlWRq\n" + | |
| "JH5U3vU0y515C0aEE+j0lUHlxMGQD2ut+sJ6BZqcTBl5d8ns1TSckEH31DBDN3Fw\n" + | |
| "uMLqEWBOjwt1MMT3Z+kR7ekuheJYbYHbJ2VtnKQd4jHmLly+/p+UqaQ6dIvQxq82\n" + | |
| "ggZIUNWjGKwXS2vKl6O9EDu/QaAX9e059pf3UxAxGtJjeKXWJvt1e96T53+2+kXp\n" + | |
| "j0/PuyT6F0o+grY08tCJnw7kTB4sE2qfALdwSblvyjBDOYtS4Xj5nycMpd+4Qse4\n" + | |
| "2+irNBdZ63pqqQIDAQABo4IC+jCCAvYwHwYDVR0jBBgwFoAUjYxexFStiuF36Zv5\n" + | |
| "mwXhuAGNYeEwHQYDVR0OBBYEFH+9CNXAwWW4+jyizee51r8x4ofHMA4GA1UdDwEB\n" + | |
| "/wQEAwIFoDAMBgNVHRMBAf8EAjAAMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEF\n" + | |
| "BQcDAjBJBgNVHSAEQjBAMDQGCysGAQQBsjEBAgIHMCUwIwYIKwYBBQUHAgEWF2h0\n" + | |
| "dHBzOi8vc2VjdGlnby5jb20vQ1BTMAgGBmeBDAECATCBhAYIKwYBBQUHAQEEeDB2\n" + | |
| "ME8GCCsGAQUFBzAChkNodHRwOi8vY3J0LnNlY3RpZ28uY29tL1NlY3RpZ29SU0FE\n" + | |
| "b21haW5WYWxpZGF0aW9uU2VjdXJlU2VydmVyQ0EuY3J0MCMGCCsGAQUFBzABhhdo\n" + | |
| "dHRwOi8vb2NzcC5zZWN0aWdvLmNvbTAjBgNVHREEHDAaggwqLmFwYWNoZS5vcmeC\n" + | |
| "CmFwYWNoZS5vcmcwggF+BgorBgEEAdZ5AgQCBIIBbgSCAWoBaAB2AEalVet1+pEg\n" + | |
| "MLWiiWn0830RLEF0vv1JuIWr8vxw/m1HAAABehHLqfgAAAQDAEcwRQIgINH3CquJ\n" + | |
| "zTAprwjdo2cEWkMzpaNoP1SOI4xGl68PF2oCIQC77eD7K6Smx4Fv/z/sTKk21Psb\n" + | |
| "ZhmVq5YoqhwRKuMgVAB2AEHIyrHfIkZKEMahOglCh15OMYsbA+vrS8do8JBilgb2\n" + | |
| "AAABehHLqcEAAAQDAEcwRQIhANh++zJa9AE4U0DsHIFq6bW40b1OfGfH8uUdmjEZ\n" + | |
| "s1jzAiBIRtJeFVmobSnbFKlOr8BGfD2L/hg1rkAgJlKY5oFShgB2ACl5vvCeOTkh\n" + | |
| "8FZzn2Old+W+V32cYAr4+U1dJlwlXceEAAABehHLqZ4AAAQDAEcwRQIhAOZDfvU8\n" + | |
| "Hz80I6Iyj2rv8+yWBVq1XVixI8bMykdCO6ADAiAWj8cJ9g1zxko4dJu8ouJf+Pwl\n" + | |
| "0bbhhuJHhy/f5kiaszANBgkqhkiG9w0BAQsFAAOCAQEAlkdB7FZtVQz39TDNKR4u\n" + | |
| "I8VQsTH5n4Kg+zVc0pptI7HGUWtp5PjBAEsvJ/G/NQXsjVflQaNPRRd7KNZycZL1\n" + | |
| "jls6GdVoWVno6O5aLS7cCnb0tTlb8srhb9vdLZkSoCVCZLVjik5s2TLfpLsBKrTP\n" + | |
| "leVY3n9TBZH+vyKLHt4WHR23Z+74xDsuXunoPGXQVV8ymqTtfohaoM19jP99vjY7\n" + | |
| "DL/289XjMSfyPFqlpU4JDM7lY/kJSKB/C4eQglT8Sgm0h/kj5hdT2uMJBIQZIJVv\n" + | |
| "241fAVUPgrYAESOMm2TVA9r1OzeoUNlKw+e3+vjTR6sfDDp/iRKcEVQX4u9+CxZp\n" + | |
| "9g==\n-----END CERTIFICATE-----"; | |
| DirectDownloadCertificateResponse response = new DirectDownloadCertificateResponse(); | |
| helper.handleCertificateResponse(certStr, response); | |
| assertEquals("3", response.getVersion()); | |
| assertEquals("CN=*.apache.org", response.getSubject()); | |
| } | |
| @Test | |
| public void testAutoScaleVmGroupResponse() { | |
| AutoScaleVmGroupVO vmGroup = new AutoScaleVmGroupVO(1L, 2L, 3L, 4L, "test", 5, 6, 7, 8, new Date(), 9L, AutoScaleVmGroup.State.ENABLED); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.findAutoScaleVmProfileById(anyLong())).thenReturn(null); | |
| when(ApiDBUtils.findLoadBalancerById(anyLong())).thenReturn(null); | |
| when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO()); | |
| when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO()); | |
| when(ApiDBUtils.countAvailableVmsByGroupId(anyLong())).thenReturn(9); | |
| AutoScaleVmGroupResponse response = apiResponseHelper.createAutoScaleVmGroupResponse(vmGroup); | |
| assertEquals("test", response.getName()); | |
| assertEquals(5, response.getMinMembers()); | |
| assertEquals(6, response.getMaxMembers()); | |
| assertEquals(8, response.getInterval()); | |
| assertEquals(9, response.getAvailableVirtualMachineCount()); | |
| assertEquals(AutoScaleVmGroup.State.ENABLED.toString(), response.getState()); | |
| assertNull(response.getNetworkName()); | |
| assertNull(response.getLbProvider()); | |
| assertNull(response.getPublicIp()); | |
| assertNull(response.getPublicPort()); | |
| assertNull(response.getPrivatePort()); | |
| } | |
| } | |
| @Test | |
| public void testAutoScaleVmGroupResponseWithNetwork() { | |
| AutoScaleVmGroupVO vmGroup = new AutoScaleVmGroupVO(1L, 2L, 3L, 4L, "test", 5, 6, 7, 8, new Date(), 9L, AutoScaleVmGroup.State.ENABLED); | |
| LoadBalancerVO lb = new LoadBalancerVO(null, null, null, 0L, 8080, 8081, null, 0L, 0L, 1L, null, null); | |
| NetworkVO network = new NetworkVO(1L, null, null, null, 2L, 1L, 2L, 3L, | |
| "testnetwork", "displaytext", "networkdomain", null, 1L, null, null, false, null, false); | |
| IPAddressVO ipAddressVO = new IPAddressVO(new Ip("10.10.10.10"), 1L, 1L, 1L,false); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.findAutoScaleVmProfileById(anyLong())).thenReturn(null); | |
| when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO()); | |
| when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO()); | |
| when(ApiDBUtils.findLoadBalancerById(anyLong())).thenReturn(lb); | |
| when(ApiDBUtils.findNetworkById(anyLong())).thenReturn(network); | |
| when(ntwkSrvcDaoMock.getProviderForServiceInNetwork(anyLong(), any())).thenReturn("VirtualRouter"); | |
| when(ApiDBUtils.findIpAddressById(anyLong())).thenReturn(ipAddressVO); | |
| AutoScaleVmGroupResponse response = apiResponseHelper.createAutoScaleVmGroupResponse(vmGroup); | |
| assertEquals("test", response.getName()); | |
| assertEquals(5, response.getMinMembers()); | |
| assertEquals(6, response.getMaxMembers()); | |
| assertEquals(8, response.getInterval()); | |
| assertEquals(AutoScaleVmGroup.State.ENABLED.toString(), response.getState()); | |
| assertEquals("testnetwork", response.getNetworkName()); | |
| assertEquals("VirtualRouter", response.getLbProvider()); | |
| assertEquals("10.10.10.10", response.getPublicIp()); | |
| assertEquals("8080", response.getPublicPort()); | |
| assertEquals("8081", response.getPrivatePort()); | |
| } | |
| } | |
| @Test | |
| public void testAutoScaleVmProfileResponse() { | |
| AutoScaleVmProfileVO vmProfile = new AutoScaleVmProfileVO(zoneId, domainId, accountId, serviceOfferingId, templateId, null, null, userdata, null, autoScaleUserId); | |
| vmProfile.setUserDataId(userdataId); | |
| vmProfile.setUserDataDetails(userdataDetails); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO()); | |
| when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO()); | |
| UserData.UserDataOverridePolicy templatePolicy = UserData.UserDataOverridePolicy.APPEND; | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| when(ApiDBUtils.findTemplateById(anyLong())).thenReturn(templateVO); | |
| when(templateVO.getUserDataOverridePolicy()).thenReturn(templatePolicy); | |
| UserDataVO userDataVO = Mockito.mock(UserDataVO.class); | |
| String userDataUuid = "userDataUuid"; | |
| String userDataName = "userDataName"; | |
| when(userDataDaoMock.findById(anyLong())).thenReturn(userDataVO); | |
| when(userDataVO.getUuid()).thenReturn(userDataUuid); | |
| when(userDataVO.getName()).thenReturn(userDataName); | |
| AutoScaleVmProfileResponse response = apiResponseHelper.createAutoScaleVmProfileResponse(vmProfile); | |
| assertEquals(templatePolicy.toString(), response.getUserDataPolicy()); | |
| assertEquals(userdata, response.getUserData()); | |
| assertEquals(userDataUuid, response.getUserDataId()); | |
| assertEquals(userDataName, response.getUserDataName()); | |
| assertEquals(userdataDetails, response.getUserDataDetails()); | |
| } | |
| } | |
| @Test | |
| public void testAutoScaleVmProfileResponseWithoutUserData() { | |
| AutoScaleVmProfileVO vmProfile = new AutoScaleVmProfileVO(zoneId, domainId, accountId, serviceOfferingId, templateId, null, null, null, null, autoScaleUserId); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.findAccountById(anyLong())).thenReturn(new AccountVO()); | |
| when(ApiDBUtils.findDomainById(anyLong())).thenReturn(new DomainVO()); | |
| VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class); | |
| when(ApiDBUtils.findTemplateById(anyLong())).thenReturn(templateVO); | |
| AutoScaleVmProfileResponse response = apiResponseHelper.createAutoScaleVmProfileResponse(vmProfile); | |
| assertNull(response.getUserDataPolicy()); | |
| assertNull(response.getUserData()); | |
| assertNull(response.getUserDataId()); | |
| assertNull(response.getUserDataName()); | |
| assertNull(response.getUserDataDetails()); | |
| } | |
| } | |
| @Test | |
| public void testCreateTrafficTypeResponse() { | |
| PhysicalNetworkVO pnet = new PhysicalNetworkVO(); | |
| pnet.addIsolationMethod("VXLAN"); | |
| pnet.addIsolationMethod("STT"); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.findPhysicalNetworkById(anyLong())).thenReturn(pnet); | |
| String xenLabel = "xen"; | |
| String kvmLabel = "kvm"; | |
| String vmwareLabel = "vmware"; | |
| String simulatorLabel = "simulator"; | |
| String hypervLabel = "hyperv"; | |
| String ovmLabel = "ovm"; | |
| String vlan = "vlan"; | |
| String trafficType = "Public"; | |
| PhysicalNetworkTrafficType pnetTrafficType = new PhysicalNetworkTrafficTypeVO(pnet.getId(), Networks.TrafficType.getTrafficType(trafficType), xenLabel, kvmLabel, vmwareLabel, simulatorLabel, vlan, hypervLabel, ovmLabel); | |
| TrafficTypeResponse response = apiResponseHelper.createTrafficTypeResponse(pnetTrafficType); | |
| assertFalse(UUID.fromString(response.getId()).toString().isEmpty()); | |
| assertEquals(response.getphysicalNetworkId(), pnet.getUuid()); | |
| assertEquals(response.getTrafficType(), trafficType); | |
| assertEquals(response.getXenLabel(), xenLabel); | |
| assertEquals(response.getKvmLabel(), kvmLabel); | |
| assertEquals(response.getVmwareLabel(), vmwareLabel); | |
| assertEquals(response.getHypervLabel(), hypervLabel); | |
| assertEquals(response.getOvm3Label(), ovmLabel); | |
| assertEquals(response.getVlan(), vlan); | |
| assertEquals(response.getIsolationMethods(), "VXLAN,STT"); | |
| } | |
| } | |
| private UnmanagedInstanceTO getUnmanagedInstanceForTests() { | |
| UnmanagedInstanceTO instance = Mockito.mock(UnmanagedInstanceTO.class); | |
| Mockito.when(instance.getPowerState()).thenReturn(UnmanagedInstanceTO.PowerState.PowerOff); | |
| Mockito.when(instance.getClusterName()).thenReturn("CL1"); | |
| UnmanagedInstanceTO.Disk disk = Mockito.mock(UnmanagedInstanceTO.Disk.class); | |
| Mockito.when(disk.getDiskId()).thenReturn("0"); | |
| Mockito.when(disk.getLabel()).thenReturn("Hard disk 1"); | |
| Mockito.when(disk.getCapacity()).thenReturn(17179869184L); | |
| Mockito.when(disk.getPosition()).thenReturn(0); | |
| Mockito.when(instance.getDisks()).thenReturn(List.of(disk)); | |
| UnmanagedInstanceTO.Nic nic = Mockito.mock(UnmanagedInstanceTO.Nic.class); | |
| Mockito.when(nic.getNicId()).thenReturn("Network adapter 1"); | |
| Mockito.when(nic.getMacAddress()).thenReturn("aa:bb:cc:dd:ee:ff"); | |
| Mockito.when(instance.getNics()).thenReturn(List.of(nic)); | |
| return instance; | |
| } | |
| @Test | |
| public void testCreateUnmanagedInstanceResponseVmwareDcVms() { | |
| UnmanagedInstanceTO instance = getUnmanagedInstanceForTests(); | |
| UnmanagedInstanceResponse response = apiResponseHelper.createUnmanagedInstanceResponse(instance, null, null); | |
| Assert.assertEquals(1, response.getDisks().size()); | |
| Assert.assertEquals(1, response.getNics().size()); | |
| } | |
| @Test | |
| public void createQuarantinedIpsResponseTestReturnsObject() { | |
| String quarantinedIpUuid = "quarantined_ip_uuid"; | |
| Long previousOwnerId = 300L; | |
| String previousOwnerUuid = "previous_owner_uuid"; | |
| String previousOwnerName = "previous_owner_name"; | |
| Long removerAccountId = 400L; | |
| String removerAccountUuid = "remover_account_uuid"; | |
| Long publicIpAddressId = 500L; | |
| String publicIpAddress = "1.2.3.4"; | |
| Date created = new Date(599L); | |
| Date removed = new Date(600L); | |
| Date endDate = new Date(601L); | |
| String removalReason = "removalReason"; | |
| PublicIpQuarantine quarantinedIpMock = Mockito.mock(PublicIpQuarantine.class); | |
| IPAddressVO ipAddressVoMock = Mockito.mock(IPAddressVO.class); | |
| Account previousOwner = Mockito.mock(Account.class); | |
| Account removerAccount = Mockito.mock(Account.class); | |
| Mockito.when(quarantinedIpMock.getUuid()).thenReturn(quarantinedIpUuid); | |
| Mockito.when(quarantinedIpMock.getPreviousOwnerId()).thenReturn(previousOwnerId); | |
| Mockito.when(quarantinedIpMock.getPublicIpAddressId()).thenReturn(publicIpAddressId); | |
| Mockito.doReturn(ipAddressVoMock).when(ipAddressDaoMock).findById(publicIpAddressId); | |
| Mockito.when(ipAddressVoMock.getAddress()).thenReturn(new Ip(publicIpAddress)); | |
| Mockito.doReturn(previousOwner).when(accountManagerMock).getAccount(previousOwnerId); | |
| Mockito.when(previousOwner.getUuid()).thenReturn(previousOwnerUuid); | |
| Mockito.when(previousOwner.getName()).thenReturn(previousOwnerName); | |
| Mockito.when(quarantinedIpMock.getCreated()).thenReturn(created); | |
| Mockito.when(quarantinedIpMock.getRemoved()).thenReturn(removed); | |
| Mockito.when(quarantinedIpMock.getEndDate()).thenReturn(endDate); | |
| Mockito.when(quarantinedIpMock.getRemovalReason()).thenReturn(removalReason); | |
| Mockito.when(quarantinedIpMock.getRemoverAccountId()).thenReturn(removerAccountId); | |
| Mockito.when(removerAccount.getUuid()).thenReturn(removerAccountUuid); | |
| Mockito.doReturn(removerAccount).when(accountManagerMock).getAccount(removerAccountId); | |
| IpQuarantineResponse result = apiResponseHelper.createQuarantinedIpsResponse(quarantinedIpMock); | |
| Assert.assertEquals(quarantinedIpUuid, result.getId()); | |
| Assert.assertEquals(publicIpAddress, result.getPublicIpAddress()); | |
| Assert.assertEquals(previousOwnerUuid, result.getPreviousOwnerId()); | |
| Assert.assertEquals(previousOwnerName, result.getPreviousOwnerName()); | |
| Assert.assertEquals(created, result.getCreated()); | |
| Assert.assertEquals(removed, result.getRemoved()); | |
| Assert.assertEquals(endDate, result.getEndDate()); | |
| Assert.assertEquals(removalReason, result.getRemovalReason()); | |
| Assert.assertEquals(removerAccountUuid, result.getRemoverAccountId()); | |
| Assert.assertEquals("quarantinedip", result.getResponseName()); | |
| } | |
| @Test | |
| public void testCapacityListingForSingleTag() { | |
| Capacity c1 = Mockito.mock(Capacity.class); | |
| Mockito.when(c1.getTag()).thenReturn("tag1"); | |
| Capacity c2 = Mockito.mock(Capacity.class); | |
| Mockito.when(c2.getTag()).thenReturn("tag1"); | |
| Capacity c3 = Mockito.mock(Capacity.class); | |
| Mockito.when(c3.getTag()).thenReturn("tag2"); | |
| Capacity c4 = Mockito.mock(Capacity.class); | |
| Assert.assertTrue(apiResponseHelper.capacityListingForSingleTag(List.of(c1, c2))); | |
| Assert.assertFalse(apiResponseHelper.capacityListingForSingleTag(List.of(c1, c2, c3))); | |
| Assert.assertFalse(apiResponseHelper.capacityListingForSingleTag(List.of(c4, c2, c3))); | |
| } | |
| @Test | |
| public void testCapacityListingForSingleNonGpuType() { | |
| Capacity c1 = Mockito.mock(Capacity.class); | |
| Mockito.when(c1.getCapacityType()).thenReturn((short)Resource.ResourceType.user_vm.getOrdinal()); | |
| Capacity c2 = Mockito.mock(Capacity.class); | |
| Mockito.when(c2.getCapacityType()).thenReturn((short)Resource.ResourceType.user_vm.getOrdinal()); | |
| Capacity c3 = Mockito.mock(Capacity.class); | |
| Mockito.when(c3.getCapacityType()).thenReturn((short)Resource.ResourceType.volume.getOrdinal()); | |
| Capacity c4 = Mockito.mock(Capacity.class); | |
| Assert.assertTrue(apiResponseHelper.capacityListingForSingleNonGpuType(List.of(c1, c2))); | |
| Assert.assertFalse(apiResponseHelper.capacityListingForSingleNonGpuType(List.of(c1, c2, c3))); | |
| } | |
| @Test | |
| public void testCreateGuestOSCategoryResponse_WithResourceIcon() { | |
| GuestOsCategory guestOsCategory = Mockito.mock(GuestOsCategory.class); | |
| ResourceIconVO resourceIconVO = Mockito.mock(ResourceIconVO.class); | |
| String uuid = UUID.randomUUID().toString(); | |
| String name = "Ubuntu"; | |
| boolean featured = true; | |
| Mockito.when(guestOsCategory.getUuid()).thenReturn(uuid); | |
| Mockito.when(guestOsCategory.getName()).thenReturn(name); | |
| Mockito.when(guestOsCategory.isFeatured()).thenReturn(featured); | |
| ResourceIconResponse mockIconResponse = Mockito.mock(ResourceIconResponse.class); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| Mockito.when(ApiDBUtils.getResourceIconByResourceUUID(uuid, ResourceTag.ResourceObjectType.GuestOsCategory)).thenReturn(resourceIconVO); | |
| Mockito.when(ApiDBUtils.newResourceIconResponse(resourceIconVO)).thenReturn(mockIconResponse); | |
| GuestOSCategoryResponse response = apiResponseHelper.createGuestOSCategoryResponse(guestOsCategory); | |
| Assert.assertNotNull(response); | |
| Assert.assertEquals(uuid, response.getId()); | |
| Assert.assertEquals(name, response.getName()); | |
| Object obj = ReflectionTestUtils.getField(response, "featured"); | |
| if (obj == null) { | |
| Assert.fail("Invalid featured value"); | |
| } | |
| Assert.assertTrue((Boolean)obj); | |
| obj = ReflectionTestUtils.getField(response, "resourceIconResponse"); | |
| Assert.assertNotNull(obj); | |
| Assert.assertEquals("oscategory", response.getObjectName()); | |
| } | |
| } | |
| @Test | |
| public void testCreateGuestOSCategoryResponse_WithoutResourceIcon() { | |
| GuestOsCategory guestOsCategory = Mockito.mock(GuestOsCategory.class); | |
| String uuid = "1234"; | |
| String name = "Ubuntu"; | |
| boolean featured = false; | |
| Mockito.when(guestOsCategory.getUuid()).thenReturn(uuid); | |
| Mockito.when(guestOsCategory.getName()).thenReturn(name); | |
| Mockito.when(guestOsCategory.isFeatured()).thenReturn(featured); | |
| try (MockedStatic<ApiDBUtils> ignored = Mockito.mockStatic(ApiDBUtils.class)) { | |
| when(ApiDBUtils.getResourceIconByResourceUUID(uuid, ResourceTag.ResourceObjectType.GuestOsCategory)).thenReturn(null); | |
| GuestOSCategoryResponse response = apiResponseHelper.createGuestOSCategoryResponse(guestOsCategory); | |
| Assert.assertNotNull(response); | |
| Assert.assertEquals(uuid, response.getId()); | |
| Assert.assertEquals(name, response.getName()); | |
| Object obj = ReflectionTestUtils.getField(response, "featured"); | |
| if (obj == null) { | |
| Assert.fail("Invalid featured value"); | |
| } | |
| Assert.assertFalse((Boolean)obj); | |
| obj = ReflectionTestUtils.getField(response, "resourceIconResponse"); | |
| Assert.assertNull(obj); | |
| Assert.assertEquals("oscategory", response.getObjectName()); | |
| } | |
| } | |
| @Test | |
| public void testCreateGuestOSCategoryResponse_WithShowIconFalse() { | |
| GuestOsCategory guestOsCategory = Mockito.mock(GuestOsCategory.class); | |
| Mockito.when(guestOsCategory.getUuid()).thenReturn(UUID.randomUUID().toString()); | |
| try (MockedStatic<ApiDBUtils> mockedStatic = Mockito.mockStatic(ApiDBUtils.class)) { | |
| GuestOSCategoryResponse response = apiResponseHelper.createGuestOSCategoryResponse(guestOsCategory, false); | |
| Assert.assertNotNull(response); | |
| mockedStatic.verify(() -> ApiDBUtils.getResourceIconByResourceUUID(Mockito.any(), Mockito.any()), | |
| Mockito.never()); | |
| } | |
| } | |
| @Test | |
| public void testGetResourceIconsUsingOsCategory_withValidData() { | |
| TemplateResponse template1 = Mockito.mock(TemplateResponse.class); | |
| when(template1.getId()).thenReturn("t1"); | |
| when(template1.getOsTypeCategoryId()).thenReturn(100L); | |
| TemplateResponse template2 = Mockito.mock(TemplateResponse.class); | |
| when(template2.getId()).thenReturn("t2"); | |
| when(template2.getOsTypeCategoryId()).thenReturn(200L); | |
| List<TemplateResponse> responses = Arrays.asList(template1, template2); | |
| Map<Long, ResourceIcon> icons = new HashMap<>(); | |
| ResourceIcon icon1 = Mockito.mock(ResourceIcon.class); | |
| ResourceIcon icon2 = Mockito.mock(ResourceIcon.class); | |
| icons.put(100L, icon1); | |
| icons.put(200L, icon2); | |
| when(resourceIconManager.getByResourceTypeAndIds(Mockito.eq(ResourceTag.ResourceObjectType.GuestOsCategory), Mockito.anySet())) | |
| .thenReturn(icons); | |
| Map<String, ResourceIcon> result = apiResponseHelper.getResourceIconsUsingOsCategory(responses); | |
| assertEquals(2, result.size()); | |
| assertEquals(icon1, result.get("t1")); | |
| assertEquals(icon2, result.get("t2")); | |
| } | |
| @Test | |
| public void testGetResourceIconsUsingOsCategory_missingIcons() { | |
| TemplateResponse template1 = Mockito.mock(TemplateResponse.class); | |
| when(template1.getId()).thenReturn("t1"); | |
| when(template1.getOsTypeCategoryId()).thenReturn(100L); | |
| List<TemplateResponse> responses = List.of(template1); | |
| when(resourceIconManager.getByResourceTypeAndIds(Mockito.eq(ResourceTag.ResourceObjectType.GuestOsCategory), Mockito.anySet())).thenReturn(Collections.emptyMap()); | |
| Map<String, ResourceIcon> result = apiResponseHelper.getResourceIconsUsingOsCategory(responses); | |
| assertTrue(result.containsKey("t1")); | |
| assertNull(result.get("t1")); | |
| } | |
| @Test | |
| public void testUpdateTemplateIsoResponsesForIcons_withMixedIcons() { | |
| TemplateResponse template1 = Mockito.mock(TemplateResponse.class); | |
| when(template1.getId()).thenReturn("t1"); | |
| TemplateResponse template2 = Mockito.mock(TemplateResponse.class); | |
| when(template2.getId()).thenReturn("t2"); | |
| List<TemplateResponse> responses = Arrays.asList(template1, template2); | |
| Map<String, ResourceIcon> isoIcons = new HashMap<>(); | |
| isoIcons.put("t1", Mockito.mock(ResourceIcon.class)); | |
| when(resourceIconManager.getByResourceTypeAndUuids(ResourceTag.ResourceObjectType.ISO, Set.of("t1", "t2"))) | |
| .thenReturn(isoIcons); | |
| Map<String, ResourceIcon> fallbackIcons = Map.of("t2", Mockito.mock(ResourceIcon.class)); | |
| Mockito.doReturn(fallbackIcons).when(apiResponseHelper).getResourceIconsUsingOsCategory(Mockito.anyList()); | |
| ResourceIconResponse iconResponse1 = new ResourceIconResponse(); | |
| ResourceIconResponse iconResponse2 = new ResourceIconResponse(); | |
| Mockito.doReturn(iconResponse1).when(apiResponseHelper).createResourceIconResponse(isoIcons.get("t1")); | |
| Mockito.doReturn(iconResponse2).when(apiResponseHelper).createResourceIconResponse(fallbackIcons.get("t2")); | |
| apiResponseHelper.updateTemplateIsoResponsesForIcons(responses, ResourceTag.ResourceObjectType.ISO); | |
| verify(template1).setResourceIconResponse(iconResponse1); | |
| verify(template2).setResourceIconResponse(iconResponse2); | |
| } | |
| @Test | |
| public void testUpdateTemplateIsoResponsesForIcons_emptyInput() { | |
| apiResponseHelper.updateTemplateIsoResponsesForIcons(Collections.emptyList(), | |
| ResourceTag.ResourceObjectType.Template); | |
| Mockito.verify(resourceIconManager, Mockito.never()).getByResourceTypeAndUuids(Mockito.any(), | |
| Mockito.anyCollection()); | |
| } | |
| private ConsoleSessionResponse getExpectedConsoleSessionResponseForTests(boolean fullView) { | |
| ConsoleSessionResponse expected = new ConsoleSessionResponse(); | |
| expected.setId("uuid"); | |
| expected.setCreated(new Date()); | |
| expected.setAcquired(new Date()); | |
| expected.setRemoved(new Date()); | |
| expected.setConsoleEndpointCreatorAddress("127.0.0.1"); | |
| expected.setClientAddress("127.0.0.1"); | |
| if (fullView) { | |
| expected.setDomain("domain"); | |
| expected.setDomainPath("domainPath"); | |
| expected.setDomainId("domainUuid"); | |
| expected.setUser("user"); | |
| expected.setUserId("userUuid"); | |
| expected.setAccount("account"); | |
| expected.setAccountId("accountUuid"); | |
| expected.setHostName("host"); | |
| expected.setHostId("hostUuid"); | |
| expected.setVmId("vmUuid"); | |
| expected.setVmName("vmName"); | |
| } | |
| return expected; | |
| } | |
| @Test | |
| public void createConsoleSessionResponseTestShouldReturnRestrictedResponse() { | |
| ConsoleSessionResponse expected = getExpectedConsoleSessionResponseForTests(false); | |
| try (MockedStatic<ApiDBUtils> apiDBUtilsStaticMock = Mockito.mockStatic(ApiDBUtils.class)) { | |
| Mockito.when(consoleSessionMock.getUuid()).thenReturn(expected.getId()); | |
| Mockito.when(consoleSessionMock.getDomainId()).thenReturn(2L); | |
| Mockito.when(consoleSessionMock.getCreated()).thenReturn(expected.getCreated()); | |
| Mockito.when(consoleSessionMock.getAcquired()).thenReturn(expected.getAcquired()); | |
| Mockito.when(consoleSessionMock.getRemoved()).thenReturn(expected.getRemoved()); | |
| Mockito.when(consoleSessionMock.getConsoleEndpointCreatorAddress()).thenReturn(expected.getConsoleEndpointCreatorAddress()); | |
| Mockito.when(consoleSessionMock.getClientAddress()).thenReturn(expected.getClientAddress()); | |
| ConsoleSessionResponse response = apiResponseHelper.createConsoleSessionResponse(consoleSessionMock, ResponseObject.ResponseView.Restricted); | |
| Assert.assertEquals(expected.getId(), response.getId()); | |
| Assert.assertEquals(expected.getCreated(), response.getCreated()); | |
| Assert.assertEquals(expected.getAcquired(), response.getAcquired()); | |
| Assert.assertEquals(expected.getRemoved(), response.getRemoved()); | |
| Assert.assertEquals(expected.getConsoleEndpointCreatorAddress(), response.getConsoleEndpointCreatorAddress()); | |
| Assert.assertEquals(expected.getClientAddress(), response.getClientAddress()); | |
| } | |
| } | |
| @Test | |
| public void createConsoleSessionResponseTestShouldReturnFullResponse() { | |
| ConsoleSessionResponse expected = getExpectedConsoleSessionResponseForTests(true); | |
| try (MockedStatic<ApiDBUtils> apiDBUtilsStaticMock = Mockito.mockStatic(ApiDBUtils.class)) { | |
| Mockito.when(consoleSessionMock.getUuid()).thenReturn(expected.getId()); | |
| Mockito.when(consoleSessionMock.getDomainId()).thenReturn(2L); | |
| Mockito.when(consoleSessionMock.getAccountId()).thenReturn(2L); | |
| Mockito.when(consoleSessionMock.getUserId()).thenReturn(2L); | |
| Mockito.when(consoleSessionMock.getHostId()).thenReturn(2L); | |
| Mockito.when(consoleSessionMock.getInstanceId()).thenReturn(2L); | |
| Mockito.when(consoleSessionMock.getCreated()).thenReturn(expected.getCreated()); | |
| Mockito.when(consoleSessionMock.getAcquired()).thenReturn(expected.getAcquired()); | |
| Mockito.when(consoleSessionMock.getRemoved()).thenReturn(expected.getRemoved()); | |
| Mockito.when(consoleSessionMock.getConsoleEndpointCreatorAddress()).thenReturn(expected.getConsoleEndpointCreatorAddress()); | |
| Mockito.when(consoleSessionMock.getClientAddress()).thenReturn(expected.getClientAddress()); | |
| apiDBUtilsStaticMock.when(() -> ApiDBUtils.findDomainById(2L)).thenReturn(domainVOMock); | |
| Mockito.when(domainVOMock.getName()).thenReturn(expected.getDomain()); | |
| Mockito.when(domainVOMock.getPath()).thenReturn(expected.getDomainPath()); | |
| Mockito.when(domainVOMock.getUuid()).thenReturn(expected.getDomainId()); | |
| Mockito.when(apiResponseHelper.findUserById(2L)).thenReturn(userVOMock); | |
| Mockito.when(userVOMock.getUsername()).thenReturn(expected.getUser()); | |
| Mockito.when(userVOMock.getUuid()).thenReturn(expected.getUserId()); | |
| Mockito.when(ApiDBUtils.findAccountById(2L)).thenReturn(accountVOMock); | |
| Mockito.when(accountVOMock.getAccountName()).thenReturn(expected.getAccount()); | |
| Mockito.when(accountVOMock.getUuid()).thenReturn(expected.getAccountId()); | |
| Mockito.when(apiResponseHelper.findHostById(2L)).thenReturn(hostVOMock); | |
| Mockito.when(hostVOMock.getUuid()).thenReturn(expected.getHostId()); | |
| Mockito.when(hostVOMock.getName()).thenReturn(expected.getHostName()); | |
| apiDBUtilsStaticMock.when(() -> ApiDBUtils.findVMInstanceById(2L)).thenReturn(vmInstanceVOMock); | |
| Mockito.when(vmInstanceVOMock.getUuid()).thenReturn(expected.getVmId()); | |
| Mockito.when(vmInstanceVOMock.getInstanceName()).thenReturn(expected.getVmName()); | |
| ConsoleSessionResponse response = apiResponseHelper.createConsoleSessionResponse(consoleSessionMock, ResponseObject.ResponseView.Full); | |
| Assert.assertEquals(expected.getId(), response.getId()); | |
| Assert.assertEquals(expected.getCreated(), response.getCreated()); | |
| Assert.assertEquals(expected.getAcquired(), response.getAcquired()); | |
| Assert.assertEquals(expected.getRemoved(), response.getRemoved()); | |
| Assert.assertEquals(expected.getConsoleEndpointCreatorAddress(), response.getConsoleEndpointCreatorAddress()); | |
| Assert.assertEquals(expected.getClientAddress(), response.getClientAddress()); | |
| Assert.assertEquals(expected.getDomain(), response.getDomain()); | |
| Assert.assertEquals(expected.getDomainPath(), response.getDomainPath()); | |
| Assert.assertEquals(expected.getDomainId(), response.getDomainId()); | |
| Assert.assertEquals(expected.getUser(), response.getUser()); | |
| Assert.assertEquals(expected.getUserId(), response.getUserId()); | |
| Assert.assertEquals(expected.getAccount(), response.getAccount()); | |
| Assert.assertEquals(expected.getAccountId(), response.getAccountId()); | |
| Assert.assertEquals(expected.getHostId(), response.getHostId()); | |
| Assert.assertEquals(expected.getHostName(), response.getHostName()); | |
| Assert.assertEquals(expected.getVmId(), response.getVmId()); | |
| Assert.assertEquals(expected.getVmName(), response.getVmName()); | |
| } | |
| } | |
| } |