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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.servlets;
  22
  23 import static java.util.Collections.emptyList;
  24 import static java.util.Collections.emptyMap;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.mockito.ArgumentMatchers.anyBoolean;
  27 import static org.mockito.ArgumentMatchers.anyString;
  28 import static org.mockito.Mockito.when;
  29
  30 import fj.data.Either;
  31 import java.io.File;
  32 import java.util.Arrays;
  33 import java.util.List;
  34 import java.util.Map;
  35 import javax.servlet.ServletContext;
  36 import javax.servlet.http.HttpServletRequest;
  37 import javax.servlet.http.HttpSession;
  38 import javax.ws.rs.client.Entity;
  39 import javax.ws.rs.core.MediaType;
  40 import javax.ws.rs.core.Response;
  41 import org.apache.commons.lang3.tuple.ImmutablePair;
  42 import org.eclipse.jetty.http.HttpStatus;
  43 import org.glassfish.hk2.utilities.binding.AbstractBinder;
  44 import org.glassfish.jersey.client.ClientConfig;
  45 import org.glassfish.jersey.media.multipart.FormDataMultiPart;
  46 import org.glassfish.jersey.media.multipart.MultiPart;
  47 import org.glassfish.jersey.media.multipart.MultiPartFeature;
  48 import org.glassfish.jersey.media.multipart.file.FileDataBodyPart;
  49 import org.glassfish.jersey.server.ResourceConfig;
  50 import org.glassfish.jersey.test.JerseyTest;
  51 import org.glassfish.jersey.test.TestProperties;
  52 import org.junit.jupiter.api.AfterEach;
  53 import org.junit.jupiter.api.BeforeAll;
  54 import org.junit.jupiter.api.BeforeEach;
  55 import org.junit.jupiter.api.Test;
  56 import org.junit.jupiter.api.TestInstance;
  57 import org.junit.jupiter.api.TestInstance.Lifecycle;
  58 import org.mockito.Mock;
  59 import org.mockito.Mockito;
  60 import org.mockito.MockitoAnnotations;
  61 import org.openecomp.sdc.be.components.impl.ArtifactTypeImportManager;
  62 import org.openecomp.sdc.be.components.impl.CapabilityTypeImportManager;
  63 import org.openecomp.sdc.be.components.impl.CategoriesImportManager;
  64 import org.openecomp.sdc.be.components.impl.DataTypeImportManager;
  65 import org.openecomp.sdc.be.components.impl.GroupTypeImportManager;
  66 import org.openecomp.sdc.be.components.impl.InterfaceLifecycleTypeImportManager;
  67 import org.openecomp.sdc.be.components.impl.PolicyTypeImportManager;
  68 import org.openecomp.sdc.be.components.impl.RelationshipTypeImportManager;
  69 import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
  70 import org.openecomp.sdc.be.config.ConfigurationManager;
  71 import org.openecomp.sdc.be.config.SpringConfig;
  72 import org.openecomp.sdc.be.dao.api.ActionStatus;
  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.CapabilityTypeDefinition;
  77 import org.openecomp.sdc.be.model.DataTypeDefinition;
  78 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  79 import org.openecomp.sdc.be.model.InterfaceDefinition;
  80 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  81 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
  82 import org.openecomp.sdc.be.model.User;
  83 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  84 import org.openecomp.sdc.be.user.Role;
  85 import org.openecomp.sdc.be.user.UserBusinessLogic;
  86 import org.openecomp.sdc.common.api.ConfigurationSource;
  87 import org.openecomp.sdc.common.api.Constants;
  88 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  89 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  90 import org.openecomp.sdc.exception.ResponseFormat;
  91 import org.springframework.context.ApplicationContext;
  92 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  93 import org.springframework.web.context.WebApplicationContext;
  94
  95 @TestInstance(Lifecycle.PER_CLASS)
  96 class TypesUploadServletTest extends JerseyTest {
  97
  98     @Mock
  99     private HttpServletRequest request;
 100     @Mock
 101     private HttpSession session;
 102     @Mock
 103     private ServletContext servletContext;
 104     @Mock
 105     private WebAppContextWrapper webAppContextWrapper;
 106     @Mock
 107     private WebApplicationContext webApplicationContext;
 108     @Mock
 109     private CapabilityTypeImportManager capabilityTypeImportManager;
 110     @Mock
 111     private DataTypeImportManager dataTypeImportManager;
 112     @Mock
 113     private RelationshipTypeImportManager relationshipTypeImportManager;
 114     @Mock
 115     private PolicyTypeImportManager policyTypeImportManager;
 116     @Mock
 117     private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
 118     @Mock
 119     private GroupTypeImportManager groupTypeImportManager;
 120     @Mock
 121     private CategoriesImportManager categoriesImportManager;
 122     @Mock
 123     private ServletUtils servletUtils;
 124     @Mock
 125     private UserBusinessLogic userAdmin;
 126     @Mock
 127     private ComponentsUtils componentUtils;
 128     @Mock
 129     private ResponseFormat responseFormat;
 130     @Mock
 131     private ArtifactTypeImportManager artifactTypeImportManager;
 132
 133     @BeforeAll
 134     public void setup() {
 135         ExternalConfiguration.setAppName("catalog-be");
 136         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 137         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webApplicationContext);
 138         when(webApplicationContext.getBean(CapabilityTypeImportManager.class)).thenReturn(capabilityTypeImportManager);
 139         when(webApplicationContext.getBean(DataTypeImportManager.class)).thenReturn(dataTypeImportManager);
 140         when(webApplicationContext.getBean(RelationshipTypeImportManager.class)).thenReturn(relationshipTypeImportManager);
 141         when(webApplicationContext.getBean(PolicyTypeImportManager.class)).thenReturn(policyTypeImportManager);
 142         when(webApplicationContext.getBean(InterfaceLifecycleTypeImportManager.class)).thenReturn(interfaceLifecycleTypeImportManager);
 143         when(webApplicationContext.getBean(GroupTypeImportManager.class)).thenReturn(groupTypeImportManager);
 144         when(webApplicationContext.getBean(CategoriesImportManager.class)).thenReturn(categoriesImportManager);
 145         when(webApplicationContext.getBean(ArtifactTypeImportManager.class)).thenReturn(artifactTypeImportManager);
 146         when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils);
 147         when(servletUtils.getComponentsUtils()).thenReturn(componentUtils);
 148         when(servletUtils.getUserAdmin()).thenReturn(userAdmin);
 149         final String userId = "jh0003";
 150         final User user = new User(userId);
 151         user.setRole(Role.ADMIN.name());
 152         when(userAdmin.getUser(userId)).thenReturn(user);
 153         when(request.getHeader(Constants.USER_ID_HEADER)).thenReturn(userId);
 154         when(responseFormat.getStatus()).thenReturn(HttpStatus.CREATED_201);
 155         when(componentUtils.getResponseFormat(ActionStatus.CREATED)).thenReturn(responseFormat);
 156         when(componentUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
 157     }
 158
 159     @BeforeEach
 160     public void before() throws Exception {
 161         super.setUp();
 162     }
 163
 164     @AfterEach
 165     void after() throws Exception {
 166         super.tearDown();
 167     }
 168
 169     @Test
 170     void creatingCapabilityTypeSuccessTest() {
 171         final ImmutablePair<CapabilityTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new CapabilityTypeDefinition(), true);
 172         final Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 173         when(capabilityTypeImportManager.createCapabilityTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 174         final FileDataBodyPart filePart = new FileDataBodyPart("capabilityTypeZip", new File("src/test/resources/types/capabilityTypes.zip"));
 175         MultiPart multipartEntity = new FormDataMultiPart();
 176         multipartEntity.bodyPart(filePart);
 177
 178         final Response response = target().path("/v1/catalog/uploadType/capability").request(MediaType.APPLICATION_JSON)
 179             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 180
 181         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 182     }
 183
 184     @Test
 185     void creatingCapabilityType_Either_isRight_FailedTest() {
 186         final Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> either = Either.right(new ResponseFormat(500));
 187         when(capabilityTypeImportManager.createCapabilityTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 188         final FileDataBodyPart filePart = new FileDataBodyPart("capabilityTypeZip", new File("src/test/resources/types/capabilityTypes.zip"));
 189         MultiPart multipartEntity = new FormDataMultiPart();
 190         multipartEntity.bodyPart(filePart);
 191
 192         final Response response = target().path("/v1/catalog/uploadType/capability").request(MediaType.APPLICATION_JSON)
 193             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 194
 195         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 196     }
 197
 198     @Test
 199     void creatingCapabilityTypeWithModelSuccessTest() {
 200         final ImmutablePair<CapabilityTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new CapabilityTypeDefinition(), true);
 201         final Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 202         when(capabilityTypeImportManager.createCapabilityTypes(anyString(), Mockito.eq("testModel"), Mockito.anyBoolean())).thenReturn(
 203             either);
 204         final FileDataBodyPart filePart = new FileDataBodyPart("capabilityTypeZip", new File("src/test/resources/types/capabilityTypes.zip"));
 205         FormDataMultiPart multipartEntity = new FormDataMultiPart();
 206         multipartEntity.bodyPart(filePart);
 207         multipartEntity.field("model", "testModel");
 208
 209         final Response response = target().path("/v1/catalog/uploadType/capability").request(MediaType.APPLICATION_JSON)
 210             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 211
 212         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 213     }
 214
 215     @Test
 216     void creatingDataTypeSuccessTest() {
 217         final ImmutablePair<DataTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new DataTypeDefinition(), true);
 218         final Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 219         when(dataTypeImportManager.createDataTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 220         final FileDataBodyPart filePart = new FileDataBodyPart("dataTypesZip", new File("src/test/resources/types/datatypes.zip"));
 221         MultiPart multipartEntity = new FormDataMultiPart();
 222         multipartEntity.bodyPart(filePart);
 223
 224         final Response response = target().path("/v1/catalog/uploadType/datatypes").request(MediaType.APPLICATION_JSON)
 225             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 226
 227         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 228     }
 229
 230     @Test
 231     void creatingDataType_Either_isRight_FailedTest() {
 232         final Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat> either = Either.right(new ResponseFormat(500));
 233         when(dataTypeImportManager.createDataTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 234         final FileDataBodyPart filePart = new FileDataBodyPart("dataTypesZip", new File("src/test/resources/types/datatypes.zip"));
 235         MultiPart multipartEntity = new FormDataMultiPart();
 236         multipartEntity.bodyPart(filePart);
 237
 238         final Response response = target().path("/v1/catalog/uploadType/datatypes").request(MediaType.APPLICATION_JSON)
 239             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 240
 241         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 242     }
 243
 244     @Test
 245     void creatingDataType_AlreadyExists_FailedTest() {
 246         final ImmutablePair<DataTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new DataTypeDefinition(), false);
 247         final Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 248         when(dataTypeImportManager.createDataTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 249         final FileDataBodyPart filePart = new FileDataBodyPart("dataTypesZip", new File("src/test/resources/types/datatypes.zip"));
 250         MultiPart multipartEntity = new FormDataMultiPart();
 251         multipartEntity.bodyPart(filePart);
 252
 253         final Response response = target().path("/v1/catalog/uploadType/datatypes").request(MediaType.APPLICATION_JSON)
 254             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 255
 256         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 257     }
 258
 259     @Test
 260     void creatingDataTypeWithModelSuccessTest() {
 261         final ImmutablePair<DataTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new DataTypeDefinition(), true);
 262         final Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 263         when(dataTypeImportManager.createDataTypes(anyString(), Mockito.eq("testModel"), Mockito.anyBoolean())).thenReturn(either);
 264         final FileDataBodyPart filePart = new FileDataBodyPart("dataTypesZip", new File("src/test/resources/types/datatypes.zip"));
 265         FormDataMultiPart multipartEntity = new FormDataMultiPart();
 266         multipartEntity.bodyPart(filePart);
 267         multipartEntity.field("model", "testModel");
 268
 269         final Response response = target().path("/v1/catalog/uploadType/datatypes").request(MediaType.APPLICATION_JSON)
 270             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 271
 272         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 273     }
 274
 275     @Test
 276     void creatingRelationshipTypeSuccessTest() {
 277         final ImmutablePair<RelationshipTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new RelationshipTypeDefinition(), true);
 278         final Either<List<ImmutablePair<RelationshipTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 279         when(relationshipTypeImportManager.createRelationshipTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 280         final FileDataBodyPart filePart = new FileDataBodyPart("relationshipTypeZip", new File("src/test/resources/types/relationship.zip"));
 281         MultiPart multipartEntity = new FormDataMultiPart();
 282         multipartEntity.bodyPart(filePart);
 283
 284         final Response response = target().path("/v1/catalog/uploadType/relationship").request(MediaType.APPLICATION_JSON)
 285             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 286
 287         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 288     }
 289
 290     @Test
 291     void creatingRelationshipType_AlreadyExists_FailedTest() {
 292         final ImmutablePair<RelationshipTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new RelationshipTypeDefinition(), false);
 293         final Either<List<ImmutablePair<RelationshipTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 294         when(relationshipTypeImportManager.createRelationshipTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(either);
 295         final FileDataBodyPart filePart = new FileDataBodyPart("relationshipTypeZip", new File("src/test/resources/types/relationship.zip"));
 296         MultiPart multipartEntity = new FormDataMultiPart();
 297         multipartEntity.bodyPart(filePart);
 298
 299         final Response response = target().path("/v1/catalog/uploadType/relationship").request(MediaType.APPLICATION_JSON)
 300             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 301
 302         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 303     }
 304
 305     @Test
 306     void creatingRelationshipTypeWithModelSuccessTest() {
 307         final ImmutablePair<RelationshipTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new RelationshipTypeDefinition(), true);
 308         final Either<List<ImmutablePair<RelationshipTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 309         when(relationshipTypeImportManager.createRelationshipTypes(anyString(), Mockito.eq("testModel"), Mockito.anyBoolean())).thenReturn(
 310             either);
 311         final FileDataBodyPart filePart = new FileDataBodyPart("relationshipTypeZip", new File("src/test/resources/types/relationship.zip"));
 312         FormDataMultiPart multipartEntity = new FormDataMultiPart();
 313         multipartEntity.bodyPart(filePart);
 314         multipartEntity.field("model", "testModel");
 315
 316         final Response response = target().path("/v1/catalog/uploadType/relationship").request(MediaType.APPLICATION_JSON)
 317             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 318
 319         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 320     }
 321
 322     @Test
 323     void creatingPolicyTypeSuccessTest() {
 324         final ImmutablePair<PolicyTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new PolicyTypeDefinition(), true);
 325         final Either<List<ImmutablePair<PolicyTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 326         when(policyTypeImportManager.createPolicyTypes(Mockito.any(ToscaTypeImportData.class), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(
 327             either);
 328         final FileDataBodyPart filePart = new FileDataBodyPart("policyTypesZip", new File("src/test/resources/types/policy.zip"));
 329         MultiPart multipartEntity = new FormDataMultiPart();
 330         multipartEntity.bodyPart(filePart);
 331
 332         final Response response = target().path("/v1/catalog/uploadType/policytypes").request(MediaType.APPLICATION_JSON)
 333             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 334
 335         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 336     }
 337
 338     @Test
 339     void creatingPolicyType_AlreadyExists_FailedTest() {
 340         final ImmutablePair<PolicyTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new PolicyTypeDefinition(), false);
 341         final Either<List<ImmutablePair<PolicyTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 342         when(policyTypeImportManager.createPolicyTypes(Mockito.any(ToscaTypeImportData.class), Mockito.isNull(), Mockito.anyBoolean())).thenReturn(
 343             either);
 344         final FileDataBodyPart filePart = new FileDataBodyPart("policyTypesZip", new File("src/test/resources/types/policy.zip"));
 345         MultiPart multipartEntity = new FormDataMultiPart();
 346         multipartEntity.bodyPart(filePart);
 347
 348         final Response response = target().path("/v1/catalog/uploadType/policytypes").request(MediaType.APPLICATION_JSON)
 349             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 350
 351         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 352     }
 353
 354     @Test
 355     void creatingPolicyTypeWithModelSuccessTest() {
 356         final ImmutablePair<PolicyTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new PolicyTypeDefinition(), true);
 357         final Either<List<ImmutablePair<PolicyTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 358         when(policyTypeImportManager.createPolicyTypes(Mockito.any(ToscaTypeImportData.class), Mockito.eq("testModel"),
 359             Mockito.anyBoolean())).thenReturn(either);
 360         final FileDataBodyPart filePart = new FileDataBodyPart("policyTypesZip", new File("src/test/resources/types/policy.zip"));
 361         FormDataMultiPart multipartEntity = new FormDataMultiPart();
 362         multipartEntity.bodyPart(filePart);
 363         multipartEntity.field("model", "testModel");
 364
 365         final Response response = target().path("/v1/catalog/uploadType/policytypes").request(MediaType.APPLICATION_JSON)
 366             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 367
 368         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 369     }
 370
 371     @Test
 372     void creatingInterfaceLifecycleTypeSuccessTest() {
 373         final ImmutablePair<InterfaceDefinition, Boolean> immutablePair = new ImmutablePair<>(new InterfaceDefinition(), true);
 374         final Either<List<InterfaceDefinition>, ResponseFormat> either = Either.left(emptyList());
 375         when(interfaceLifecycleTypeImportManager.createLifecycleTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean()))
 376             .thenReturn(either);
 377         final FileDataBodyPart filePart = new FileDataBodyPart("interfaceLifecycleTypeZip",
 378             new File("src/test/resources/types/interfaceLifecycleTypes.zip"));
 379         MultiPart multipartEntity = new FormDataMultiPart();
 380         multipartEntity.bodyPart(filePart);
 381
 382         final Response response = target().path("/v1/catalog/uploadType/interfaceLifecycle").request(MediaType.APPLICATION_JSON)
 383             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 384
 385         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 386     }
 387
 388     @Test
 389     void creatingInterfaceLifecycleType_Either_isRight_FailedTest() {
 390         final Either<List<InterfaceDefinition>, ResponseFormat> either = Either.right(new ResponseFormat(500));
 391         when(interfaceLifecycleTypeImportManager.createLifecycleTypes(anyString(), Mockito.isNull(), Mockito.anyBoolean()))
 392             .thenReturn(either);
 393         final FileDataBodyPart filePart = new FileDataBodyPart("interfaceLifecycleTypeZip",
 394             new File("src/test/resources/types/interfaceLifecycleTypes.zip"));
 395         MultiPart multipartEntity = new FormDataMultiPart();
 396         multipartEntity.bodyPart(filePart);
 397
 398         final Response response = target().path("/v1/catalog/uploadType/interfaceLifecycle").request(MediaType.APPLICATION_JSON)
 399             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 400
 401         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 402     }
 403
 404     @Test
 405     void creatingInterfaceLifecycleTypeWithModelSuccessTest() {
 406         final ImmutablePair<InterfaceDefinition, Boolean> immutablePair = new ImmutablePair<>(new InterfaceDefinition(), true);
 407         final Either<List<InterfaceDefinition>, ResponseFormat> either = Either.left(emptyList());
 408         when(interfaceLifecycleTypeImportManager.createLifecycleTypes(anyString(), Mockito.eq("testModel"), Mockito.anyBoolean()))
 409             .thenReturn(either);
 410         final FileDataBodyPart filePart = new FileDataBodyPart("interfaceLifecycleTypeZip",
 411             new File("src/test/resources/types/interfaceLifecycleTypes.zip"));
 412         FormDataMultiPart multipartEntity = new FormDataMultiPart();
 413         multipartEntity.bodyPart(filePart);
 414         multipartEntity.field("model", "testModel");
 415
 416         final Response response = target().path("/v1/catalog/uploadType/interfaceLifecycle").request(MediaType.APPLICATION_JSON)
 417             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 418
 419         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 420     }
 421
 422     @Test
 423     void creatingGroupTypesSuccessTest() {
 424         final ImmutablePair<GroupTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new GroupTypeDefinition(), true);
 425         final Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 426         when(groupTypeImportManager.createGroupTypes(Mockito.any(ToscaTypeImportData.class), Mockito.isNull(), Mockito.anyBoolean()))
 427             .thenReturn(either);
 428         final FileDataBodyPart filePart = new FileDataBodyPart("groupTypesZip", new File("src/test/resources/types/group.zip"));
 429         MultiPart multipartEntity = new FormDataMultiPart();
 430         multipartEntity.bodyPart(filePart);
 431
 432         final Response response = target().path("/v1/catalog/uploadType/grouptypes").request(MediaType.APPLICATION_JSON)
 433             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 434
 435         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 436     }
 437
 438     @Test
 439     void creatingGroupTypes_AlreadyExists_FailedTest() {
 440         final ImmutablePair<GroupTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new GroupTypeDefinition(), false);
 441         final Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 442         when(groupTypeImportManager.createGroupTypes(Mockito.any(ToscaTypeImportData.class), Mockito.isNull(), Mockito.anyBoolean()))
 443             .thenReturn(either);
 444         final FileDataBodyPart filePart = new FileDataBodyPart("groupTypesZip", new File("src/test/resources/types/group.zip"));
 445         MultiPart multipartEntity = new FormDataMultiPart();
 446         multipartEntity.bodyPart(filePart);
 447
 448         final Response response = target().path("/v1/catalog/uploadType/grouptypes").request(MediaType.APPLICATION_JSON)
 449             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 450
 451         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 452     }
 453
 454     @Test
 455     void creatingGroupTypesWithModelSuccessTest() {
 456         final ImmutablePair<GroupTypeDefinition, Boolean> immutablePair = new ImmutablePair<>(new GroupTypeDefinition(), true);
 457         final Either<List<ImmutablePair<GroupTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(Arrays.asList(immutablePair));
 458         when(groupTypeImportManager.createGroupTypes(Mockito.any(ToscaTypeImportData.class), Mockito.eq("testModel"), Mockito.anyBoolean()))
 459             .thenReturn(either);
 460         final FileDataBodyPart filePart = new FileDataBodyPart("groupTypesZip", new File("src/test/resources/types/group.zip"));
 461         FormDataMultiPart multipartEntity = new FormDataMultiPart();
 462         multipartEntity.bodyPart(filePart);
 463         multipartEntity.field("model", "testModel");
 464
 465         final Response response = target().path("/v1/catalog/uploadType/grouptypes").request(MediaType.APPLICATION_JSON)
 466             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 467
 468         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 469     }
 470
 471     @Test
 472     void creatingCategoriesTypeSuccessTest() {
 473         final Either<Map<String, List<CategoryDefinition>>, ResponseFormat> either = Either.left(emptyMap());
 474         when(categoriesImportManager.createCategories(anyString())).thenReturn(either);
 475         final FileDataBodyPart filePart = new FileDataBodyPart("categoriesZip", new File("src/test/resources/types/categoryTypes.zip"));
 476         MultiPart multipartEntity = new FormDataMultiPart();
 477         multipartEntity.bodyPart(filePart);
 478
 479         final Response response = target().path("/v1/catalog/uploadType/categories").request(MediaType.APPLICATION_JSON)
 480             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 481
 482         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 483     }
 484
 485     @Test
 486     void creatingArtifactTypeSuccessTest() {
 487         when(artifactTypeImportManager.createArtifactTypes(anyString(), anyString(), anyBoolean()))
 488             .thenReturn(Either.left(emptyList()));
 489         final FileDataBodyPart filePart = new FileDataBodyPart("artifactsZip", new File("src/test/resources/types/artifactTypes.zip"));
 490         final FormDataMultiPart multipartEntity = new FormDataMultiPart();
 491         multipartEntity.bodyPart(filePart);
 492         multipartEntity.field("model", "testModel");
 493         final Response response = target().path("/v1/catalog/uploadType/artifactTypes").request(MediaType.APPLICATION_JSON)
 494             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 495         assertEquals(HttpStatus.CREATED_201, response.getStatus());
 496     }
 497
 498     @Test
 499     void creatingArtifactTypeFailTest() {
 500         when(artifactTypeImportManager.createArtifactTypes(anyString(), anyString(), anyBoolean()))
 501             .thenReturn(Either.right(new ResponseFormat(500)));
 502         final FormDataMultiPart multipartEntity = new FormDataMultiPart();
 503         multipartEntity.field("model", "testModel");
 504         final Response response = target().path("/v1/catalog/uploadType/artifactTypes").request(MediaType.APPLICATION_JSON)
 505             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 506         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
 507     }
 508
 509     @Override
 510     protected void configureClient(ClientConfig config) {
 511         config.register(MultiPartFeature.class);
 512     }
 513
 514     @Override
 515     protected ResourceConfig configure() {
 516         MockitoAnnotations.openMocks(this);
 517
 518         forceSet(TestProperties.CONTAINER_PORT, "0");
 519         final TypesUploadServlet typesUploadServlet = new TypesUploadServlet(null, null, componentUtils,
 520             servletUtils, null, capabilityTypeImportManager, interfaceLifecycleTypeImportManager,
 521             categoriesImportManager, dataTypeImportManager,
 522             groupTypeImportManager, policyTypeImportManager, relationshipTypeImportManager, artifactTypeImportManager);
 523         final ResourceConfig resourceConfig = new ResourceConfig().register(typesUploadServlet);
 524
 525         resourceConfig.register(MultiPartFeature.class);
 526         resourceConfig.register(new AbstractBinder() {
 527             @Override
 528             protected void configure() {
 529                 // The below code was cut-pasted to here from setup() because
 530                 // due to it now has
 531                 // to be executed during servlet initialization
 532                 bind(request).to(HttpServletRequest.class);
 533                 when(request.getSession()).thenReturn(session);
 534                 when(session.getServletContext()).thenReturn(servletContext);
 535                 String appConfigDir = "src/test/resources/config/catalog-be";
 536                 ConfigurationSource configurationSource = new FSConfigurationSource(
 537                     ExternalConfiguration.getChangeListener(), appConfigDir);
 538                 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 539                 for (final String mandatoryHeader : configurationManager.getConfiguration().getIdentificationHeaderFields()) {
 540                     when(request.getHeader(mandatoryHeader)).thenReturn(mandatoryHeader);
 541                 }
 542
 543                 when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR))
 544                     .thenReturn(configurationManager);
 545             }
 546         });
 547         final ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 548         resourceConfig.property("contextConfig", context);
 549
 550         return resourceConfig;
 551     }
 552 }