vid-app-common/src/test/java/org/onap/vid/mso/MsoBusinessLogicImplTest.java

   1 package org.onap.vid.mso;
   2
   3 import com.fasterxml.jackson.core.type.TypeReference;
   4 import com.fasterxml.jackson.databind.ObjectMapper;
   5 import org.mockito.*;
   6 import org.onap.portalsdk.core.util.SystemProperties;
   7 import org.onap.vid.changeManagement.RequestDetailsWrapper;
   8 import org.onap.vid.controllers.MsoController;
   9 import org.onap.vid.mso.rest.Request;
  10 import org.onap.vid.mso.rest.RequestDetails;
  11 import org.onap.vid.properties.Features;
  12 import org.springframework.test.context.ContextConfiguration;
  13 import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
  14 import org.springframework.test.context.web.WebAppConfiguration;
  15 import org.testng.Assert;
  16 import org.testng.annotations.BeforeTest;
  17 import org.testng.annotations.DataProvider;
  18 import org.testng.annotations.Test;
  19 import org.togglz.core.manager.FeatureManager;
  20
  21 import java.io.IOException;
  22 import java.nio.file.Files;
  23 import java.nio.file.Path;
  24 import java.nio.file.Paths;
  25 import java.util.List;
  26 import java.util.stream.Collectors;
  27
  28 import static org.assertj.core.api.Assertions.assertThat;
  29 import static org.mockito.Matchers.eq;
  30 import static org.mockito.Mockito.*;
  31 import static org.onap.vid.controllers.MsoController.SVC_INSTANCE_ID;
  32 import static org.onap.vid.mso.MsoBusinessLogicImpl.validateEndpointPath;
  33
  34 @ContextConfiguration(classes = {SystemProperties.class})
  35 @WebAppConfiguration
  36 public class MsoBusinessLogicImplTest extends AbstractTestNGSpringContextTests {
  37
  38     private static final String SERVICE_INSTANCE_ID = "1";
  39     private static final String VNF_INSTANCE_ID = "1";
  40     private static final String EXPECTED_SCALE_OUT_PATH = "/serviceInstantiation/v7/serviceInstances/1/vnfs/1/vfModules/scaleOut";
  41     private static final Path PATH_TO_NOT_PROCESSED_SCALE_OUT_REQUEST = Paths.get("src", "test", "resources", "payload_jsons", "scaleOutVfModulePayload.json");
  42     private static final Path PATH_TO_FINAL_SCALE_OUT_REQUEST = Paths.get("src", "test", "resources", "payload_jsons", "scaleOutVfModulePayloadToMso.json");
  43     private static final Path PATH_TO_EXPECTED_MSO_MODEL_TYPE_REQ = Paths.get("src", "test", "resources", "payload_jsons", "mso_model_info_sample_response.json");
  44     private static final Path PATH_TO_EXPECTED_MSO_SCALEOUT_REQ = Paths.get("src", "test", "resources", "payload_jsons", "mso_action_scaleout_sample_response.json");
  45     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
  46
  47     @InjectMocks
  48     private MsoBusinessLogicImpl msoBusinessLogic;
  49
  50     @Mock
  51     private FeatureManager featureManagerMock;
  52
  53     @Mock
  54     private MsoInterface msoInterfaceMock;
  55
  56
  57     @BeforeTest
  58     public void initMocks() {
  59         MockitoAnnotations.initMocks(this);
  60     }
  61
  62     @Test
  63     public void validateEndpointPath_endPointIsNotEmptyAndVaild_returnProperty() {
  64         System.setProperty("TestEnv", "123");
  65         String foundEndPoint = validateEndpointPath("TestEnv");
  66         Assert.assertEquals("123", foundEndPoint);
  67     }
  68
  69     @Test(expectedExceptions = RuntimeException.class)
  70     public void validateEndpointPath_endPointIsNull_throwRuntimeException() {
  71         validateEndpointPath("NotExists");
  72     }
  73
  74     @Test(expectedExceptions = RuntimeException.class)
  75     public void validateEndpointPath_endPointIsNotEmptyButDoesntExists_throwRuntimeException() {
  76         System.setProperty("EmptyEndPoint", "");
  77         validateEndpointPath("EmptyEndPoint");
  78     }
  79
  80
  81     //@Test(dataProvider = "unAssignOrDeleteParams")
  82     public void deleteSvcInstance_verifyEndPointPathConstructing_unAssignFeatureOffOrUnAssignFlagIsFalse(boolean isAssignFlag, String status) {
  83         Mockito.reset(msoInterfaceMock);
  84         String endpoint = validateEndpointPath(isAssignFlag ? MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE : MsoProperties.MSO_REST_API_SVC_INSTANCE);
  85         RequestDetails requestDetails = new RequestDetails();
  86
  87         when(featureManagerMock.isActive(Features.FLAG_UNASSIGN_SERVICE)).thenReturn(isAssignFlag);
  88
  89         msoBusinessLogic.deleteSvcInstance(requestDetails, "tempId", status);
  90
  91         verify(msoInterfaceMock).deleteSvcInstance(requestDetails, endpoint + "/tempId");
  92     }
  93
  94     @DataProvider
  95     public Object[][] unAssignOrDeleteParams() {
  96         return new Object[][]{
  97                 {Boolean.FALSE, "active"},
  98                 {Boolean.FALSE, "created"},
  99                 {Boolean.TRUE, "Active"},
 100                 {Boolean.TRUE, "unexpected-status"},
 101         };
 102     }
 103
 104     //@Test(dataProvider = "unAssignStatus")
 105     public void deleteSvcInstance_verifyEndPointPathConstructing_unAssignFeatureOnAndUnAssignFlagIsTrue(String status) {
 106         Mockito.reset(msoInterfaceMock);
 107         // in the test Features.FLAG_UNASSIGN_SERVICE is active so the endpoint should be MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE
 108         String endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
 109         RequestDetails requestDetails = new RequestDetails();
 110
 111         when(featureManagerMock.isActive(Features.FLAG_UNASSIGN_SERVICE)).thenReturn(true);
 112
 113         msoBusinessLogic.deleteSvcInstance(requestDetails, "tempId", status);
 114
 115         verify(msoInterfaceMock).unassignSvcInstance(requestDetails, endpoint + "/tempId/unassign");
 116     }
 117
 118     @DataProvider
 119     public Object[][] unAssignStatus() {
 120         return new Object[][]{
 121                 {"Created"},
 122                 {"Pendingdelete"},
 123                 {"pending-Delete"},
 124                 {"Assigned"}
 125         };
 126     }
 127
 128     @Test
 129     public void deleteVnf_verifyEndPointPathConstructing() {
 130         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 131         RequestDetails requestDetails = new RequestDetails();
 132
 133         String vnf_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, "serviceInstanceTempId");
 134
 135         msoBusinessLogic.deleteVnf(requestDetails, "serviceInstanceTempId", "vnfInstanceTempId");
 136         verify(msoInterfaceMock).deleteVnf(requestDetails, vnf_endpoint + "/vnfInstanceTempId");
 137     }
 138
 139     @Test
 140     public void deleteVfModule_verifyEndPointPathConstructing() {
 141         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 142         RequestDetails requestDetails = new RequestDetails();
 143
 144         String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, "serviceInstanceTempId").replaceFirst(MsoController.VNF_INSTANCE_ID, "vnfInstanceTempId");
 145
 146         msoBusinessLogic.deleteVfModule(requestDetails, "serviceInstanceTempId", "vnfInstanceTempId", "vfModuleTempId");
 147         verify(msoInterfaceMock).deleteVfModule(requestDetails, vf__modules_endpoint + "/vfModuleTempId");
 148     }
 149
 150
 151     @Test
 152     public void shouldSendProperScaleOutRequest() throws IOException {
 153         ArgumentCaptor<RequestDetailsWrapper> requestDetailsWrapperArgumentCaptor = ArgumentCaptor.forClass(RequestDetailsWrapper.class);
 154         org.onap.vid.changeManagement.RequestDetails requestDetails = getScaleOutRequest();
 155         RequestDetailsWrapper expectedRequestWrapper = getExpectedRequestWrapper();
 156
 157         msoBusinessLogic.scaleOutVfModuleInstance(requestDetails, SERVICE_INSTANCE_ID, VNF_INSTANCE_ID);
 158
 159         verify(msoInterfaceMock).scaleOutVFModuleInstance(requestDetailsWrapperArgumentCaptor.capture(), eq(EXPECTED_SCALE_OUT_PATH));
 160         RequestDetailsWrapper actual = requestDetailsWrapperArgumentCaptor.getAllValues().get(0);
 161
 162         assertThat(expectedRequestWrapper.requestDetails).isEqualTo(actual.requestDetails);
 163     }
 164
 165     @Test
 166     public void shouldFilterOutOrchestrationRequestsNotAllowedInDashboard() throws IOException {
 167         String vnfModelTypeOrchestrationRequests = getFileContentAsString(PATH_TO_EXPECTED_MSO_MODEL_TYPE_REQ);
 168         String scaleOutActionOrchestrationRequests = getFileContentAsString(PATH_TO_EXPECTED_MSO_SCALEOUT_REQ);
 169
 170         MsoResponseWrapper msoResponseWrapperMock = mock(MsoResponseWrapper.class);
 171         when(msoInterfaceMock.getOrchestrationRequestsForDashboard(any(String.class), any(String.class), any(String.class), any(RestObject.class)))
 172                 .thenReturn(msoResponseWrapperMock);
 173         when(msoResponseWrapperMock.getEntity()).thenReturn(vnfModelTypeOrchestrationRequests, scaleOutActionOrchestrationRequests);
 174
 175         List<Request> filteredOrchestrationReqs = msoBusinessLogic.getOrchestrationRequestsForDashboard();
 176
 177         assertThat(filteredOrchestrationReqs).hasSize(3);
 178         assertThat(MsoBusinessLogicImpl.DASHBOARD_ALLOWED_TYPES)
 179                 .containsAll(filteredOrchestrationReqs
 180                         .stream()
 181                         .map(el -> el.getRequestType().toUpperCase())
 182                         .collect(Collectors.toList()));
 183         assertThat(filteredOrchestrationReqs
 184                 .stream()
 185                 .map(org.onap.vid.domain.mso.Request::getRequestScope)
 186                 .collect(Collectors.toList()))
 187                 .containsOnly("vnf", "vfModule");
 188     }
 189
 190
 191     private String getFileContentAsString(Path pathToFile) throws IOException {
 192         return new String(Files.readAllBytes(pathToFile));
 193     }
 194
 195     private org.onap.vid.changeManagement.RequestDetails getScaleOutRequest() throws IOException {
 196         return OBJECT_MAPPER.readValue(PATH_TO_NOT_PROCESSED_SCALE_OUT_REQUEST.toFile(), org.onap.vid.changeManagement.RequestDetails.class);
 197     }
 198
 199     private RequestDetailsWrapper getExpectedRequestWrapper() throws IOException {
 200         return OBJECT_MAPPER.readValue(PATH_TO_FINAL_SCALE_OUT_REQUEST.toFile(), new TypeReference<RequestDetailsWrapper<org.onap.vid.changeManagement.RequestDetails>>() {
 201         });
 202     }
 203 }
 204