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

   1 package org.openecomp.sdc.be.servlets;
   2
   3 import com.fasterxml.jackson.databind.DeserializationFeature;
   4 import fj.data.Either;
   5 import org.apache.commons.lang3.tuple.ImmutablePair;
   6 import org.eclipse.jetty.http.HttpStatus;
   7 import org.glassfish.jersey.client.ClientConfig;
   8 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
   9 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
  10 import org.glassfish.jersey.logging.LoggingFeature;
  11 import org.glassfish.jersey.media.multipart.FormDataMultiPart;
  12 import org.glassfish.jersey.media.multipart.MultiPart;
  13 import org.glassfish.jersey.media.multipart.MultiPartFeature;
  14 import org.glassfish.jersey.media.multipart.file.FileDataBodyPart;
  15 import org.glassfish.jersey.server.ResourceConfig;
  16 import org.junit.BeforeClass;
  17 import org.junit.Test;
  18 import org.mockito.Mockito;
  19 import org.openecomp.sdc.be.components.impl.CommonImportManager;
  20 import org.openecomp.sdc.be.components.validation.AccessValidations;
  21 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  22 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  23 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  24 import org.openecomp.sdc.be.impl.ComponentsUtils;
  25 import org.openecomp.sdc.be.model.AnnotationTypeDefinition;
  26 import org.openecomp.sdc.be.model.operations.StorageException;
  27 import org.openecomp.sdc.be.model.operations.impl.AnnotationTypeOperations;
  28 import org.openecomp.sdc.be.model.operations.impl.CommonTypeOperations;
  29 import org.openecomp.sdc.be.model.operations.impl.OperationUtils;
  30 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  31 import org.openecomp.sdc.be.resources.data.AnnotationTypeData;
  32 import org.openecomp.sdc.common.api.Constants;
  33 import org.springframework.context.annotation.Bean;
  34 import org.springframework.context.annotation.Import;
  35
  36 import javax.ws.rs.client.Entity;
  37 import javax.ws.rs.core.MediaType;
  38 import javax.ws.rs.core.Response;
  39 import java.io.File;
  40 import java.util.ArrayList;
  41 import java.util.List;
  42
  43 import static java.util.Collections.emptyMap;
  44 import static org.assertj.core.api.Assertions.assertThat;
  45 import static org.mockito.ArgumentMatchers.any;
  46 import static org.mockito.ArgumentMatchers.anyList;
  47 import static org.mockito.ArgumentMatchers.anyMap;
  48 import static org.mockito.ArgumentMatchers.anyString;
  49 import static org.mockito.ArgumentMatchers.eq;
  50 import static org.mockito.ArgumentMatchers.isA;
  51 import static org.mockito.Mockito.*;
  52
  53 public class TypesUploadEndpointTest extends JerseySpringBaseTest {
  54
  55     static final String userId = "jh0003";
  56
  57     private static AccessValidations accessValidations;
  58     private static TitanGenericDao titanGenericDao;
  59     private static PropertyOperation propertyOperation;
  60     private static ComponentsUtils componentUtils;
  61     private static OperationUtils operationUtils;
  62
  63     @org.springframework.context.annotation.Configuration
  64     @Import(BaseTestConfig.class)
  65     static class TypesUploadTestConfig {
  66
  67         @Bean
  68         TypesUploadEndpoint typesUploadEndpoint() {
  69             return new TypesUploadEndpoint(commonImportManager(), annotationTypeOperations(), accessValidations);
  70         }
  71
  72         @Bean
  73         CommonImportManager commonImportManager() {
  74             return new CommonImportManager(componentUtils, propertyOperation);
  75         }
  76
  77         @Bean
  78         AnnotationTypeOperations annotationTypeOperations() {
  79             return new AnnotationTypeOperations(commonTypeOperations());
  80         }
  81
  82         @Bean
  83         CommonTypeOperations commonTypeOperations() {
  84             return new CommonTypeOperations(titanGenericDao, propertyOperation, operationUtils);
  85         }
  86     }
  87
  88     @BeforeClass
  89     public static void initClass() {
  90         titanGenericDao = mock(TitanGenericDao.class);
  91         accessValidations = mock(AccessValidations.class);
  92         propertyOperation = mock(PropertyOperation.class);
  93         componentUtils = Mockito.mock(ComponentsUtils.class);
  94         operationUtils = Mockito.mock(OperationUtils.class);
  95     }
  96
  97     @Override
  98     protected void configureClient(ClientConfig config) {
  99         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider()
 100                 .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 101         config.register(jacksonJsonProvider);
 102         config.register(MultiPartFeature.class);
 103     }
 104
 105     @Override
 106     protected ResourceConfig configure() {
 107         return super.configure(TypesUploadEndpointTest.TypesUploadTestConfig.class)
 108                 .register(TypesUploadEndpoint.class)
 109                 .property(LoggingFeature.LOGGING_FEATURE_LOGGER_LEVEL_SERVER, "WARNING");
 110     }
 111
 112     @Test
 113     public void creatingAnnotationTypeSuccessTest() {
 114         doNothing().when(accessValidations).validateUserExists(eq(userId), anyString());
 115         when(titanGenericDao.createNode(isA(AnnotationTypeData.class), eq(AnnotationTypeData.class))).thenReturn(Either.left(new AnnotationTypeData()));
 116         when(titanGenericDao.getNode(anyString(), eq("org.openecomp.annotations.source.1.0.annotationtype"), eq(AnnotationTypeData.class))).thenReturn(Either.left(new AnnotationTypeData()));
 117         when(titanGenericDao.getByCriteria(eq(NodeTypeEnum.AnnotationType), anyMap(), eq(AnnotationTypeData.class))).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
 118         when(propertyOperation.addPropertiesToElementType(anyString(), eq(NodeTypeEnum.AnnotationType), anyList())).thenReturn(Either.left(emptyMap()));
 119         when(propertyOperation.fillPropertiesList(anyString(), eq(NodeTypeEnum.AnnotationType), any())).thenReturn(TitanOperationStatus.OK);
 120         when(propertyOperation.getTitanGenericDao()).thenReturn(titanGenericDao);
 121         when(titanGenericDao.commit()).thenReturn(TitanOperationStatus.OK);
 122         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.OK);
 123         FileDataBodyPart filePart = new FileDataBodyPart("annotationTypesZip", new File("src/test/resources/types/annotationTypes.zip"));
 124         MultiPart multipartEntity = new FormDataMultiPart();
 125         multipartEntity.bodyPart(filePart);
 126
 127         Response response = target().path("/v1/catalog/uploadType/annotationtypes")
 128                 .request(MediaType.APPLICATION_JSON)
 129                 .header(Constants.USER_ID_HEADER, userId)
 130                 .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 131         assertThat(response.getStatus()).isEqualTo(HttpStatus.CREATED_201);
 132         assertThat(Boolean.valueOf(getTypeActionResult(response))).isTrue();
 133     }
 134
 135     private String getTypeActionResult(Response response) {
 136         String typeResult = "";
 137         String body = response.readEntity(String.class);
 138         int indexColon = body.lastIndexOf(':');
 139         if (indexColon > 0) {
 140             int indexCurly = body.indexOf('}', indexColon);
 141             if (indexCurly > 0) {
 142                 typeResult = body.substring(indexColon+1, indexCurly);
 143             }
 144         }
 145         return typeResult;
 146     }
 147
 148     @Test
 149     public void creatingAnnotationTypeFailureTest() {
 150         doNothing().when(accessValidations).validateUserExists(eq(userId), anyString());
 151         when(titanGenericDao.createNode(isA(AnnotationTypeData.class), eq(AnnotationTypeData.class))).thenReturn(Either.left(new AnnotationTypeData()));
 152         when(titanGenericDao.getNode(anyString(), eq("org.openecomp.annotations.source.1.0.annotationtype"), eq(AnnotationTypeData.class))).thenReturn(Either.left(new AnnotationTypeData()));
 153         when(titanGenericDao.getByCriteria(eq(NodeTypeEnum.AnnotationType), anyMap(), eq(AnnotationTypeData.class))).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
 154         when(propertyOperation.addPropertiesToElementType(anyString(), eq(NodeTypeEnum.AnnotationType), anyList())).thenThrow(new StorageException(TitanOperationStatus.MATCH_NOT_FOUND));
 155         when(propertyOperation.fillPropertiesList(anyString(), eq(NodeTypeEnum.AnnotationType), any())).thenReturn(TitanOperationStatus.OK);
 156         when(propertyOperation.getTitanGenericDao()).thenReturn(titanGenericDao);
 157         when(titanGenericDao.commit()).thenReturn(TitanOperationStatus.OK);
 158         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.OK);
 159         FileDataBodyPart filePart = new FileDataBodyPart("annotationTypesZip", new File("src/test/resources/types/annotationTypes.zip"));
 160         MultiPart multipartEntity = new FormDataMultiPart();
 161         multipartEntity.bodyPart(filePart);
 162
 163         Response response = target().path("/v1/catalog/uploadType/annotationtypes")
 164                 .request(MediaType.APPLICATION_JSON)
 165                 .header(Constants.USER_ID_HEADER, userId)
 166                 .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 167         assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400);
 168         assertThat(Boolean.valueOf(getTypeActionResult(response))).isFalse();
 169     }
 170
 171     @Test
 172     public void singleTypeSucceeded_statusIsCreated() {
 173         List<ImmutablePair<AnnotationTypeDefinition, Boolean>> typeActionResults = new ArrayList<>();
 174         AnnotationTypeDefinition dummyDefition = new AnnotationTypeDefinition();
 175         typeActionResults.add(new ImmutablePair(dummyDefition, true));
 176         assertThat(TypesUploadEndpoint.getHttpStatus(typeActionResults).value()).isEqualTo(HttpStatus.CREATED_201);
 177     }
 178
 179     @Test
 180     public void singleTypeExists_statusIsConflict() {
 181         List<ImmutablePair<AnnotationTypeDefinition, Boolean>> typeActionResults = new ArrayList<>();
 182         AnnotationTypeDefinition dummyDefition = new AnnotationTypeDefinition();
 183         typeActionResults.add(new ImmutablePair(dummyDefition, null));
 184         assertThat(TypesUploadEndpoint.getHttpStatus(typeActionResults).value()).isEqualTo(HttpStatus.CONFLICT_409);
 185     }
 186
 187     @Test
 188     public void mixedSuccessAndExists_statusIsCreated() {
 189         List<ImmutablePair<AnnotationTypeDefinition, Boolean>> typeActionResults = new ArrayList<>();
 190         AnnotationTypeDefinition dummyDefition = new AnnotationTypeDefinition();
 191         typeActionResults.add(new ImmutablePair(dummyDefition, true));
 192         typeActionResults.add(new ImmutablePair(dummyDefition, null));
 193         assertThat(TypesUploadEndpoint.getHttpStatus(typeActionResults).value()).isEqualTo(HttpStatus.CREATED_201);
 194     }
 195
 196     @Test
 197     public void mixedSuccessAndFailure_statusIsBadRequest() {
 198         List<ImmutablePair<AnnotationTypeDefinition, Boolean>> typeActionResults = new ArrayList<>();
 199         AnnotationTypeDefinition dummyDefition = new AnnotationTypeDefinition();
 200         typeActionResults.add(new ImmutablePair(dummyDefition, true));
 201         typeActionResults.add(new ImmutablePair(dummyDefition, false));
 202         typeActionResults.add(new ImmutablePair(dummyDefition, null));
 203         assertThat(TypesUploadEndpoint.getHttpStatus(typeActionResults).value()).isEqualTo(HttpStatus.BAD_REQUEST_400);
 204     }
 205 }