catalog-be/src/test/java/org/openecomp/sdc/be/externalapi/servlet/AbstractTemplateServletTest.java

   1 /*
   2
   3  * Copyright (c) 2018 AT&T Intellectual Property.
   4
   5  *
   6
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8
   9  * you may not use this file except in compliance with the License.
  10
  11  * You may obtain a copy of the License at
  12
  13  *
  14
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16
  17  *
  18
  19  * Unless required by applicable law or agreed to in writing, software
  20
  21  * distributed under the License is distributed on an "AS IS" BASIS,
  22
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24
  25  * See the License for the specific language governing permissions and
  26
  27  * limitations under the License.
  28
  29  */
  30
  31 package org.openecomp.sdc.be.externalapi.servlet;
  32
  33 import static org.junit.Assert.assertEquals;
  34 import static org.mockito.ArgumentMatchers.anyString;
  35 import static org.mockito.Mockito.when;
  36
  37 import fj.data.Either;
  38 import java.util.Arrays;
  39 import javax.servlet.ServletContext;
  40 import javax.servlet.http.HttpServletRequest;
  41 import javax.servlet.http.HttpSession;
  42 import javax.ws.rs.client.Entity;
  43 import javax.ws.rs.core.Application;
  44 import javax.ws.rs.core.MediaType;
  45 import javax.ws.rs.core.Response;
  46 import org.apache.http.HttpStatus;
  47 import org.glassfish.hk2.utilities.binding.AbstractBinder;
  48 import org.glassfish.jersey.server.ResourceConfig;
  49 import org.glassfish.jersey.test.JerseyTest;
  50 import org.glassfish.jersey.test.TestProperties;
  51 import org.json.simple.JSONObject;
  52 import org.json.simple.parser.JSONParser;
  53 import org.junit.jupiter.api.AfterEach;
  54 import org.junit.jupiter.api.BeforeAll;
  55 import org.junit.jupiter.api.BeforeEach;
  56 import org.junit.jupiter.api.Test;
  57 import org.junit.jupiter.api.TestInstance;
  58 import org.junit.jupiter.api.TestInstance.Lifecycle;
  59 import org.mockito.Mockito;
  60 import org.mockito.stubbing.Answer;
  61 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  62 import org.openecomp.sdc.be.components.impl.ElementBusinessLogic;
  63 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  64 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  65 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
  66 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  67 import org.openecomp.sdc.be.config.ConfigurationManager;
  68 import org.openecomp.sdc.be.config.SpringConfig;
  69 import org.openecomp.sdc.be.dao.api.ActionStatus;
  70 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  71 import org.openecomp.sdc.be.ecomp.converters.AssetMetadataConverter;
  72 import org.openecomp.sdc.be.externalapi.servlet.representation.ResourceAssetMetadata;
  73 import org.openecomp.sdc.be.impl.ComponentsUtils;
  74 import org.openecomp.sdc.be.impl.ServletUtils;
  75 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  76 import org.openecomp.sdc.be.model.Resource;
  77 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  78 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  79 import org.openecomp.sdc.be.user.UserBusinessLogic;
  80 import org.openecomp.sdc.common.api.ConfigurationSource;
  81 import org.openecomp.sdc.common.api.Constants;
  82 import org.openecomp.sdc.common.datastructure.FunctionalInterfaces;
  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 @TestInstance(Lifecycle.PER_CLASS)
  91 class AbstractTemplateServletTest extends JerseyTest {
  92
  93     private final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
  94     private final HttpSession session = Mockito.mock(HttpSession.class);
  95     private final ServletContext servletContext = Mockito.mock(ServletContext.class);
  96     private final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
  97     private final WebApplicationContext webApplicationContext = Mockito.mock(WebApplicationContext.class);
  98     private final ServletUtils servletUtils = Mockito.mock(ServletUtils.class);
  99     private final ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
 100     private final ResourceImportManager resourceImportManager = Mockito.mock(ResourceImportManager.class);
 101     private final ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class);
 102     private final ServiceBusinessLogic serviceBusinessLogic = Mockito.mock(ServiceBusinessLogic.class);
 103     private final ElementBusinessLogic elementBusinessLogic = Mockito.mock(ElementBusinessLogic.class);
 104     private final Resource resource = Mockito.mock(Resource.class);
 105     private final CategoryDefinition categoryDefinition = Mockito.mock(CategoryDefinition.class);
 106     private final SubCategoryDefinition subCategoryDefinition = Mockito.mock(SubCategoryDefinition.class);
 107     private final AssetMetadataConverter assetMetadataConverter = Mockito.mock(AssetMetadataConverter.class);
 108     private final ResourceAssetMetadata resourceAssetMetadata = new ResourceAssetMetadata();
 109     private final LifecycleBusinessLogic lifecycleBusinessLogic = Mockito.mock(LifecycleBusinessLogic.class);
 110     private final UserBusinessLogic userBusinessLogic = Mockito.mock(UserBusinessLogic.class);
 111     private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
 112
 113     @BeforeAll
 114     public void setup() {
 115         ExternalConfiguration.setAppName("catalog-be");
 116         when(request.getSession()).thenReturn(session);
 117         when(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER)).thenReturn("mockXEcompInstanceId");
 118         when(request.getHeader(Constants.USER_ID_HEADER)).thenReturn("mockAttID");
 119         when(request.getRequestURL()).thenReturn(new StringBuffer("sdc/v1/catalog/abstract"));
 120
 121         when(session.getServletContext()).thenReturn(servletContext);
 122         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR))
 123             .thenReturn(webAppContextWrapper);
 124         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webApplicationContext);
 125
 126         when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils);
 127         when(webApplicationContext.getBean(ResourceBusinessLogic.class)).thenReturn(resourceBusinessLogic);
 128
 129         when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
 130         mockResponseFormat();
 131
 132         when(resource.getName()).thenReturn("MockVFCMT");
 133         when(resource.getSystemName()).thenReturn("mockvfcmt");
 134         Either<Resource, ResponseFormat> eitherRet = Either.left(resource);
 135         when(componentsUtils
 136             .convertJsonToObjectUsingObjectMapper(Mockito.any(), Mockito.any(), Mockito.eq(Resource.class),
 137                 Mockito.any(),
 138                 Mockito.eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherRet);
 139
 140         when(webApplicationContext.getBean(ResourceImportManager.class)).thenReturn(resourceImportManager);
 141         when(webApplicationContext.getBean(ElementBusinessLogic.class)).thenReturn(elementBusinessLogic);
 142         when(categoryDefinition.getName()).thenReturn("Template");
 143         when(subCategoryDefinition.getName()).thenReturn("Monitoring Template");
 144         when(categoryDefinition.getSubcategories()).thenReturn(Arrays.asList(subCategoryDefinition));
 145         when(elementBusinessLogic.getAllResourceCategories())
 146             .thenReturn(Either.left(Arrays.asList(categoryDefinition)));
 147         when(resourceBusinessLogic
 148             .createResource(Mockito.eq(resource), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
 149             .thenReturn(resource);
 150         when(webApplicationContext.getBean(AssetMetadataConverter.class)).thenReturn(assetMetadataConverter);
 151         when(request.isUserInRole(anyString())).thenReturn(true);
 152
 153         Mockito.doReturn(Either.left(resourceAssetMetadata)).when(assetMetadataConverter)
 154             .convertToSingleAssetMetadata(Mockito.eq(resource), Mockito.anyString(),
 155                 Mockito.eq(true));
 156
 157         String appConfigDir = "src/test/abstract/config";
 158         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
 159             appConfigDir);
 160         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 161
 162         org.openecomp.sdc.be.config.Configuration configuration = new org.openecomp.sdc.be.config.Configuration();
 163         configuration.setJanusGraphInMemoryGraph(true);
 164
 165         configurationManager.setConfiguration(configuration);
 166     }
 167
 168     @BeforeEach
 169     public void beforeEach() throws Exception {
 170         super.setUp();
 171     }
 172
 173     @AfterEach
 174     public void afterEach() throws Exception {
 175         super.tearDown();
 176     }
 177
 178     private void mockResponseFormat() {
 179         when(componentsUtils.getResponseFormat(Mockito.any(ActionStatus.class), Mockito.any(String[].class)))
 180             .thenAnswer((Answer<ResponseFormat>) invocation -> {
 181                 ResponseFormat ret;
 182                 final ActionStatus actionStatus = invocation.getArgument(0);
 183                 switch (actionStatus) {
 184                     case CREATED: {
 185                         ret = new ResponseFormat(HttpStatus.SC_CREATED);
 186                         break;
 187                     }
 188                     default: {
 189                         ret = new ResponseFormat(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 190                         break;
 191                     }
 192                 }
 193                 return ret;
 194             });
 195     }
 196
 197     @Test
 198     void createVfcmtHappyScenario() {
 199         final JSONObject createRequest = buildCreateJsonRequest();
 200         Response response = target().path("/v1/catalog/abstract").request(MediaType.APPLICATION_JSON)
 201             .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 202             .header(Constants.USER_ID_HEADER, "mockAttID")
 203             .post(Entity.json(createRequest.toJSONString()), Response.class);
 204         assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatus());
 205     }
 206
 207     private static final String BASIC_CREATE_REQUEST = "{\r\n" +
 208         "  \"name\": \"VFCMT_1\",\r\n" +
 209         "  \"description\": \"VFCMT Description\",\r\n" +
 210         "  \"resourceType\" : \"VFCMT\",\r\n" +
 211         "  \"category\": \"Template\",\r\n" +
 212         "  \"subcategory\": \"Monitoring Template\",\r\n" +
 213         "  \"vendorName\" : \"DCAE\",\r\n" +
 214         "  \"vendorRelease\" : \"1.0\",\r\n" +
 215         "  \"tags\": [\r\n" +
 216         "    \"VFCMT_1\"\r\n" +
 217         "  ],\r\n" +
 218         "  \"icon\" : \"defaulticon\",\r\n" +
 219         "  \"contactId\": \"cs0008\"\r\n" +
 220         "}";
 221
 222     private JSONObject buildCreateJsonRequest() {
 223
 224         JSONParser parser = new JSONParser();
 225         return (JSONObject) FunctionalInterfaces.swallowException(() -> parser.parse(BASIC_CREATE_REQUEST));
 226
 227     }
 228
 229     @Override
 230     protected Application configure() {
 231         ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 232         forceSet(TestProperties.CONTAINER_PORT, "0");
 233         return new ResourceConfig()
 234             .register(createMockServlet())
 235             .register(new AbstractBinder() {
 236
 237                 @Override
 238                 protected void configure() {
 239                     bind(request).to(HttpServletRequest.class);
 240                 }
 241             })
 242             .property("contextConfig", context);
 243     }
 244
 245     private CrudExternalServlet createMockServlet() {
 246         return new CrudExternalServlet(
 247             userBusinessLogic,
 248             componentInstanceBusinessLogic,
 249             componentsUtils,
 250             servletUtils,
 251             resourceImportManager,
 252             elementBusinessLogic,
 253             assetMetadataConverter,
 254             lifecycleBusinessLogic,
 255             resourceBusinessLogic,
 256             serviceBusinessLogic);
 257     }
 258
 259 }