catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentSubstitutionFilterServletTest.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.openecomp.sdc.be.servlets;
  21
  22 import static org.assertj.core.api.Assertions.assertThat;
  23 import static org.junit.jupiter.api.Assertions.assertNotNull;
  24 import static org.mockito.ArgumentMatchers.any;
  25 import static org.mockito.ArgumentMatchers.anyInt;
  26 import static org.mockito.ArgumentMatchers.anyString;
  27 import static org.mockito.ArgumentMatchers.anyBoolean;
  28 import static org.mockito.ArgumentMatchers.nullable;
  29 import static org.mockito.ArgumentMatchers.anyList;
  30 import static org.mockito.Mockito.mock;
  31 import static org.mockito.Mockito.reset;
  32 import static org.mockito.Mockito.times;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35 import static org.openecomp.sdc.common.api.Constants.USER_ID_HEADER;
  36
  37 import com.fasterxml.jackson.core.JsonProcessingException;
  38 import com.fasterxml.jackson.databind.ObjectMapper;
  39 import java.util.Arrays;
  40 import java.util.Collections;
  41 import java.util.LinkedList;
  42 import java.util.Optional;
  43 import javax.servlet.ServletContext;
  44 import javax.servlet.http.HttpServletRequest;
  45 import javax.servlet.http.HttpSession;
  46 import javax.ws.rs.client.Entity;
  47 import javax.ws.rs.core.MediaType;
  48 import javax.ws.rs.core.Response;
  49
  50 import org.eclipse.jetty.http.HttpStatus;
  51 import org.glassfish.hk2.utilities.binding.AbstractBinder;
  52 import org.glassfish.jersey.server.ResourceConfig;
  53 import org.glassfish.jersey.test.JerseyTest;
  54 import org.glassfish.jersey.test.TestProperties;
  55 import org.junit.jupiter.api.AfterEach;
  56 import org.junit.jupiter.api.BeforeAll;
  57 import org.junit.jupiter.api.BeforeEach;
  58 import org.junit.jupiter.api.Test;
  59 import org.mockito.ArgumentMatchers;
  60 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  61 import org.openecomp.sdc.be.components.impl.ComponentSubstitutionFilterBusinessLogic;
  62 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  63 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  64 import org.openecomp.sdc.be.components.validation.UserValidations;
  65 import org.openecomp.sdc.be.config.Configuration;
  66 import org.openecomp.sdc.be.config.ConfigurationManager;
  67 import org.openecomp.sdc.be.config.SpringConfig;
  68 import org.openecomp.sdc.be.dao.api.ActionStatus;
  69 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
  70 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  71 import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
  72 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
  73 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  74 import org.openecomp.sdc.be.impl.ComponentsUtils;
  75 import org.openecomp.sdc.be.impl.ServletUtils;
  76 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  77 import org.openecomp.sdc.be.model.User;
  78 import org.openecomp.sdc.be.ui.model.UIConstraint;
  79 import org.openecomp.sdc.be.user.Role;
  80 import org.openecomp.sdc.be.user.UserBusinessLogic;
  81 import org.openecomp.sdc.common.api.Constants;
  82 import org.openecomp.sdc.common.api.ConfigurationSource;
  83 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  84 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  85 import org.openecomp.sdc.exception.ResponseFormat;
  86 import org.springframework.context.ApplicationContext;
  87 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  88 import org.springframework.web.context.WebApplicationContext;
  89
  90 public class ComponentSubstitutionFilterServletTest extends JerseyTest {
  91
  92     private static final String USER_ID = "jh0003";
  93     private static final String servicePropertyName = "controller_actor";
  94     private static final String constraintOperator = "equal";
  95     private static final String sourceType = "static";
  96     private static final String sourceName = sourceType;
  97     private static final String propertyValue = "constraintValue";
  98     private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
  99     private static final String constraintType = "properties";
 100     private static final String componentType = "services";
 101
 102     private static HttpServletRequest request;
 103     private static HttpSession session;
 104     private static ServletContext servletContext;
 105     private static WebAppContextWrapper webAppContextWrapper;
 106     private static WebApplicationContext webApplicationContext;
 107     private static UserBusinessLogic userBusinessLogic;
 108     private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 109     private static ComponentsUtils componentsUtils;
 110     private static ServletUtils servletUtils;
 111     private static ResourceImportManager resourceImportManager;
 112     private static ComponentSubstitutionFilterBusinessLogic componentSubstitutionFilterBusinessLogic;
 113     private static ResponseFormat responseFormat;
 114     private static UserValidations userValidations;
 115     private static ConfigurationManager configurationManager;
 116     private SubstitutionFilterDataDefinition substitutionFilterDataDefinition;
 117     private RequirementSubstitutionFilterPropertyDataDefinition requirementSubstitutionFilterPropertyDataDefinition;
 118     private UIConstraint uiConstraint;
 119     private String constraint;
 120     private String inputJson;
 121     private User user;
 122
 123     @BeforeAll
 124     public static void initClass() {
 125         createMocks();
 126         when(request.getSession()).thenReturn(session);
 127         when(session.getServletContext()).thenReturn(servletContext);
 128         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR))
 129             .thenReturn(webAppContextWrapper);
 130         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webApplicationContext);
 131         when(webApplicationContext.getBean(ComponentSubstitutionFilterBusinessLogic.class))
 132             .thenReturn(componentSubstitutionFilterBusinessLogic);
 133         when(request.getHeader("USER_ID")).thenReturn(USER_ID);
 134         when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils);
 135         when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
 136         String appConfigDir = "src/test/resources/config/catalog-be";
 137         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 138         configurationManager = new ConfigurationManager(configurationSource);
 139         org.openecomp.sdc.be.config.Configuration configuration = new org.openecomp.sdc.be.config.Configuration();
 140         configuration.setJanusGraphInMemoryGraph(true);
 141         configurationManager.setConfiguration(configuration);
 142         ExternalConfiguration.setAppName("catalog-be");
 143     }
 144
 145     @BeforeEach
 146     public void resetMock() throws Exception {
 147         super.setUp();
 148         reset(componentSubstitutionFilterBusinessLogic);
 149         initComponentData();
 150     }
 151
 152     @AfterEach
 153     void after() throws Exception {
 154         super.tearDown();
 155     }
 156
 157     @Test
 158     public void addSubstitutionFilterTest() throws Exception {
 159         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s";
 160         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 161
 162         when(userValidations.validateUserExists(user)).thenReturn(user);
 163         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 164         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200);
 165         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 166
 167         assertNotNull(uiConstraint);
 168         assertThat(servicePropertyName).isEqualToIgnoringCase(uiConstraint.getServicePropertyName());
 169         assertThat(constraintOperator).isEqualToIgnoringCase(uiConstraint.getConstraintOperator());
 170         assertThat(sourceType).isEqualToIgnoringCase(uiConstraint.getSourceType());
 171         assertThat(sourceName).isEqualToIgnoringCase(uiConstraint.getSourceName());
 172         assertThat(propertyValue).isEqualToIgnoringCase(uiConstraint.getValue().toString());
 173
 174         when(componentsUtils.parseToConstraint(anyString(), any(User.class), any(ComponentTypeEnum.class)))
 175             .thenReturn(Optional.of(uiConstraint));
 176
 177         assertNotNull(constraint);
 178         assertNotNull(substitutionFilterDataDefinition);
 179         assertThat(substitutionFilterDataDefinition.getProperties().getListToscaDataDefinition()).hasSize(1);
 180         assertThat("controller_actor: {equal: constraintValue}\n").isEqualToIgnoringCase(constraint);
 181         when(componentSubstitutionFilterBusinessLogic.addSubstitutionFilter(componentId, uiConstraint.getServicePropertyName(), constraint,
 182                 true, ComponentTypeEnum.SERVICE)).thenReturn(Optional.of(substitutionFilterDataDefinition));
 183
 184         final Response response = target()
 185             .path(path)
 186             .request(MediaType.APPLICATION_JSON)
 187             .header(USER_ID_HEADER, USER_ID)
 188             .post(Entity.entity(inputJson, MediaType.APPLICATION_JSON));
 189
 190         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200);
 191
 192         verify(componentSubstitutionFilterBusinessLogic, times(1))
 193                 .addSubstitutionFilter(componentId, uiConstraint.getServicePropertyName(), constraint,
 194                         true, ComponentTypeEnum.SERVICE);
 195     }
 196
 197     @Test
 198     public void addSubstitutionFilterFailConstraintParseTest() {
 199         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s";
 200         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 201
 202         when(userValidations.validateUserExists(user)).thenReturn(user);
 203         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 204         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 205
 206         when(componentsUtils.parseToConstraint(anyString(), any(User.class), nullable(ComponentTypeEnum.class)))
 207             .thenReturn(Optional.empty());
 208
 209         final Response response = target()
 210             .path(path)
 211             .request(MediaType.APPLICATION_JSON)
 212             .header(USER_ID_HEADER, USER_ID)
 213             .post(Entity.entity(inputJson, MediaType.APPLICATION_JSON));
 214
 215         assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR_500);
 216     }
 217
 218     @Test
 219     public void addSubstitutionFilterFailTest() {
 220         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s";
 221         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 222
 223         when(userValidations.validateUserExists(user)).thenReturn(user);
 224         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 225         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 226
 227         when(componentsUtils.parseToConstraint(anyString(), any(User.class), any(ComponentTypeEnum.class)))
 228             .thenReturn(Optional.of(uiConstraint));
 229
 230         final Response response = target()
 231             .path(path)
 232             .request(MediaType.APPLICATION_JSON)
 233             .header(USER_ID_HEADER, USER_ID)
 234             .post(Entity.entity(inputJson, MediaType.APPLICATION_JSON));
 235
 236         assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR_500);
 237     }
 238
 239     @Test
 240     public void updateSubstitutionFilterTest() throws BusinessLogicException {
 241         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s";
 242         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 243
 244         when(userValidations.validateUserExists(user)).thenReturn(user);
 245         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 246         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200);
 247         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 248
 249         when(componentsUtils.validateAndParseConstraint(ArgumentMatchers.any(ComponentTypeEnum.class), anyString(),
 250             any(User.class))).thenReturn(Collections.singletonList(uiConstraint));
 251
 252         when(componentSubstitutionFilterBusinessLogic.updateSubstitutionFilter(componentId.toLowerCase(),
 253             Collections.singletonList(constraint), true, ComponentTypeEnum.SERVICE))
 254             .thenReturn(Optional.ofNullable(substitutionFilterDataDefinition));
 255
 256         final Response response = target()
 257             .path(path)
 258             .request(MediaType.APPLICATION_JSON)
 259             .header(USER_ID_HEADER, USER_ID)
 260             .put(Entity.entity(inputJson, MediaType.APPLICATION_JSON));
 261
 262         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200);
 263
 264         verify(componentSubstitutionFilterBusinessLogic, times(1))
 265                 .updateSubstitutionFilter(anyString(), anyList(), anyBoolean(), any(ComponentTypeEnum.class));
 266     }
 267
 268     @Test
 269     public void updateSubstitutionFilterFailConstraintParseTest() {
 270         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s";
 271         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 272
 273         when(userValidations.validateUserExists(user)).thenReturn(user);
 274         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 275         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 276
 277         when(componentsUtils.validateAndParseConstraint(ArgumentMatchers.any(ComponentTypeEnum.class), anyString(),
 278             any(User.class))).thenReturn(Collections.emptyList());
 279
 280         final Response response = target()
 281             .path(path)
 282             .request(MediaType.APPLICATION_JSON)
 283             .header(USER_ID_HEADER, USER_ID)
 284             .put(Entity.entity(inputJson, MediaType.APPLICATION_JSON));
 285
 286         assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR_500);
 287     }
 288
 289     @Test
 290     public void updateSubstitutionFilterFailTest()  {
 291         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s";
 292         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 293
 294         when(userValidations.validateUserExists(user)).thenReturn(user);
 295         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 296         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 297
 298         when(componentsUtils.validateAndParseConstraint(ArgumentMatchers.any(ComponentTypeEnum.class), anyString(),
 299             any(User.class))).thenReturn(Collections.singletonList(uiConstraint));
 300
 301         final Response response = target()
 302             .path(path)
 303             .request(MediaType.APPLICATION_JSON)
 304             .header(USER_ID_HEADER, USER_ID)
 305             .put(Entity.entity(inputJson, MediaType.APPLICATION_JSON));
 306
 307         assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR_500);
 308     }
 309
 310     @Test
 311     public void deleteSubstitutionFilterConstraintTest() throws BusinessLogicException {
 312         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s/0";
 313         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 314
 315         when(userValidations.validateUserExists(user)).thenReturn(user);
 316         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 317         when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200);
 318         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 319
 320         when(componentSubstitutionFilterBusinessLogic.deleteSubstitutionFilter(componentId, 0,
 321                 true, ComponentTypeEnum.SERVICE))
 322             .thenReturn(Optional.ofNullable(substitutionFilterDataDefinition));
 323
 324         final Response response = target()
 325             .path(path)
 326             .request(MediaType.APPLICATION_JSON)
 327             .header(USER_ID_HEADER, USER_ID)
 328             .delete(Response.class);
 329
 330         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200);
 331
 332         verify(componentSubstitutionFilterBusinessLogic, times(1))
 333                 .deleteSubstitutionFilter(anyString(), anyInt(), anyBoolean(), any(ComponentTypeEnum.class));
 334     }
 335
 336     @Test
 337     public void deleteSubstitutionFilterConstraintFailTest() {
 338         final String pathFormat = "/v1/catalog/%s/%s/substitutionFilter/%s/0";
 339         final String path = String.format(pathFormat, componentType, componentId, constraintType);
 340
 341         when(userValidations.validateUserExists(user)).thenReturn(user);
 342         when(componentSubstitutionFilterBusinessLogic.validateUser(USER_ID)).thenReturn(user);
 343         when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 344
 345         final Response response = target()
 346             .path(path)
 347             .request(MediaType.APPLICATION_JSON)
 348             .header(USER_ID_HEADER, USER_ID)
 349             .delete(Response.class);
 350
 351         assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR_500);
 352     }
 353
 354     private static void createMocks() {
 355         request = mock(HttpServletRequest.class);
 356         userBusinessLogic = mock(UserBusinessLogic.class);
 357         componentInstanceBusinessLogic = mock(ComponentInstanceBusinessLogic.class);
 358         componentsUtils = mock(ComponentsUtils.class);
 359         servletUtils = mock(ServletUtils.class);
 360         resourceImportManager = mock(ResourceImportManager.class);
 361         componentSubstitutionFilterBusinessLogic = mock(ComponentSubstitutionFilterBusinessLogic.class);
 362
 363         session = mock(HttpSession.class);
 364         servletContext = mock(ServletContext.class);
 365         webAppContextWrapper = mock(WebAppContextWrapper.class);
 366         webApplicationContext = mock(WebApplicationContext.class);
 367         responseFormat = mock(ResponseFormat.class);
 368         userValidations = mock(UserValidations.class);
 369     }
 370
 371     @Override
 372     protected ResourceConfig configure() {
 373         forceSet(TestProperties.CONTAINER_PORT, "0");
 374         final ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 375         return new ResourceConfig(ComponentSubstitutionFilterServlet.class)
 376             .register(new AbstractBinder() {
 377                 @Override
 378                 protected void configure() {
 379                     bind(request).to(HttpServletRequest.class);
 380                     bind(userBusinessLogic).to(UserBusinessLogic.class);
 381                     bind(componentInstanceBusinessLogic).to(ComponentInstanceBusinessLogic.class);
 382                     bind(componentsUtils).to(ComponentsUtils.class);
 383                     bind(servletUtils).to(ServletUtils.class);
 384                     bind(resourceImportManager).to(ResourceImportManager.class);
 385                     bind(componentSubstitutionFilterBusinessLogic).to(ComponentSubstitutionFilterBusinessLogic.class);
 386                 }
 387             })
 388             .property("contextConfig", context);
 389     }
 390
 391     private void initComponentData() throws JsonProcessingException {
 392         uiConstraint = new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
 393         constraint = new ConstraintConvertor().convert(uiConstraint);
 394         inputJson = buildConstraintDataJson(uiConstraint);
 395
 396         requirementSubstitutionFilterPropertyDataDefinition = new RequirementSubstitutionFilterPropertyDataDefinition();
 397         requirementSubstitutionFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
 398         requirementSubstitutionFilterPropertyDataDefinition.setConstraints(new LinkedList<>(Arrays.asList(constraint)));
 399
 400         final ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> listDataDefinition =
 401             new ListDataDefinition<>(
 402                 new LinkedList<>(Arrays.asList(requirementSubstitutionFilterPropertyDataDefinition)));
 403
 404         substitutionFilterDataDefinition = new SubstitutionFilterDataDefinition();
 405         substitutionFilterDataDefinition.setProperties(listDataDefinition);
 406         substitutionFilterDataDefinition.setID("SUBSTITUTION_FILTER_UID");
 407
 408         user = new User();
 409         user.setUserId(USER_ID);
 410         user.setRole(Role.ADMIN.name());
 411     }
 412
 413     private String buildConstraintDataJson(final UIConstraint uiConstraint) throws JsonProcessingException {
 414         final ObjectMapper mapper = new ObjectMapper();
 415         return mapper.writeValueAsString(uiConstraint);
 416     }
 417
 418 }
 419