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