summaryrefslogtreecommitdiffstats
path: root/catalog-be/src/test/java
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-be/src/test/java')
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java137
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/components/path/beans/ToscaModelImportCassandraDaoMock.java39
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ModelServletTest.java138
3 files changed, 282 insertions, 32 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java
index 6c7bd5323f..b88bdfb01c 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java
@@ -19,16 +19,25 @@
package org.openecomp.sdc.be.components.impl;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
-import org.junit.jupiter.api.Order;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.TestInstance.Lifecycle;
-import org.junit.jupiter.api.TestMethodOrder;
+import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
@@ -36,10 +45,11 @@ import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.exception.BusinessException;
import org.openecomp.sdc.be.model.Model;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
+import org.openecomp.sdc.common.zip.ZipUtils;
+import org.openecomp.sdc.common.zip.exception.ZipException;
-@TestInstance(Lifecycle.PER_CLASS)
-@TestMethodOrder(OrderAnnotation.class)
class ModelBusinessLogicTest {
@InjectMocks
@@ -47,8 +57,9 @@ class ModelBusinessLogicTest {
@Mock
private ModelOperation modelOperation;
private Model model;
+ private final Path modelImportsResourcePath = Path.of("src/test/resources/modelImports");
- @BeforeAll
+ @BeforeEach
void setup() {
MockitoAnnotations.openMocks(this);
initTestData();
@@ -59,7 +70,6 @@ class ModelBusinessLogicTest {
}
@Test
- @Order(1)
void createModelTest() {
when(modelOperation.createModel(model, false)).thenReturn(model);
final Model result = modelBusinessLogic.createModel(model);
@@ -68,13 +78,116 @@ class ModelBusinessLogicTest {
}
@Test
- @Order(2)
void createModelFailTest() {
when(modelOperation.createModel(model, false))
- .thenThrow(new OperationException(ActionStatus.MODEL_ALREADY_EXISTS, model.getName()));
+ .thenThrow(ModelOperationExceptionSupplier.modelAlreadyExists(model.getName()).get());
final BusinessException exception = assertThrows(BusinessException.class, () -> modelBusinessLogic.createModel(model));
assertThat(((OperationException) exception).getActionStatus().name()).isEqualTo(ActionStatus.MODEL_ALREADY_EXISTS.name());
assertThat(((OperationException) exception).getParams()).contains(model.getName());
}
+ @Test
+ void createModelImportsSuccessTest() throws IOException, ZipException {
+ final var modelId = "modelId";
+ final var resolve = modelImportsResourcePath.resolve("modelWithSubFolderAndEmptyFolder.zip");
+ final var zipBytes = Files.readAllBytes(resolve);
+ final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(zipBytes);
+ final Map<String, byte[]> expectedZipMap = ZipUtils.readZip(zipBytes, false);
+
+ when(modelOperation.findModelByName(modelId)).thenReturn(Optional.of(new Model(modelId)));
+ doNothing().when(modelOperation).createModelImports(eq(modelId), anyMap());
+
+ modelBusinessLogic.createModelImports(modelId, byteArrayInputStream);
+
+ final ArgumentCaptor<Map<String, byte[]>> zipMapArgumentCaptor = ArgumentCaptor.forClass(Map.class);
+ verify(modelOperation).createModelImports(eq(modelId), zipMapArgumentCaptor.capture());
+ expectedZipMap.keySet().forEach(key -> assertTrue(zipMapArgumentCaptor.getValue().containsKey(key), "Expecting import " + key));
+ }
+
+ @Test
+ void createModelImportsTest_invalidModel() {
+ //given an empty model
+ final var modelId = "";
+
+ final var emptyByteArrayInputStream = new ByteArrayInputStream(new byte[0]);
+ var actualOperationException = assertThrows(OperationException.class,
+ () -> modelBusinessLogic.createModelImports(modelId, emptyByteArrayInputStream));
+
+ var expectedOperationException = ModelOperationExceptionSupplier.invalidModel(modelId).get();
+ assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
+ assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
+ assertEquals(actualOperationException.getParams()[0], expectedOperationException.getParams()[0]);
+
+ //given a null model
+ actualOperationException = assertThrows(OperationException.class,
+ () -> modelBusinessLogic.createModelImports(null, emptyByteArrayInputStream));
+
+ expectedOperationException = ModelOperationExceptionSupplier.invalidModel(null).get();
+ assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
+ assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
+ assertEquals(actualOperationException.getParams()[0], expectedOperationException.getParams()[0]);
+ }
+
+ @Test
+ void createModelImportsTest_nullInputStream() {
+ final var modelId = "modelId";
+
+ final OperationException actualOperationException = assertThrows(OperationException.class,
+ () -> modelBusinessLogic.createModelImports(modelId, null));
+
+ final OperationException expectedOperationException = ModelOperationExceptionSupplier.emptyModelImports().get();
+ assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
+ assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
+ }
+
+ @Test
+ void createModelImportsTest_emptyModelImports() throws IOException {
+ final var modelId = "modelId";
+
+ final var resolve = modelImportsResourcePath.resolve("emptyModelImports.zip");
+ final var zipBytes = Files.readAllBytes(resolve);
+ final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(zipBytes);
+
+ when(modelOperation.findModelByName(modelId)).thenReturn(Optional.of(new Model(modelId)));
+
+ final OperationException actualOperationException = assertThrows(OperationException.class,
+ () -> modelBusinessLogic.createModelImports(modelId, byteArrayInputStream));
+
+ final OperationException expectedOperationException = ModelOperationExceptionSupplier.emptyModelImports().get();
+ assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
+ assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
+ }
+
+ @Test
+ void createModelImportsTest_modelNotFound() {
+ final var modelId = "modelId";
+ final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(new byte[0]);
+
+ when(modelOperation.findModelByName(modelId)).thenReturn(Optional.empty());
+
+ final OperationException actualOperationException = assertThrows(OperationException.class,
+ () -> modelBusinessLogic.createModelImports(modelId, byteArrayInputStream));
+
+ final OperationException expectedOperationException = ModelOperationExceptionSupplier.invalidModel(modelId).get();
+ assertEquals(actualOperationException.getActionStatus(), expectedOperationException.getActionStatus());
+ assertEquals(actualOperationException.getParams().length, expectedOperationException.getParams().length);
+ }
+
+ @Test
+ void findModelSuccessTest() {
+ final var modelId = "modelId";
+ when(modelOperation.findModelByName(modelId)).thenReturn(Optional.of(new Model(modelId)));
+ final Optional<Model> actualModel = modelBusinessLogic.findModel(modelId);
+ assertTrue(actualModel.isPresent());
+ assertEquals(new Model(modelId), actualModel.get());
+ }
+
+ @Test
+ void findModelTest_emptyOrNullModelName() {
+ when(modelOperation.findModelByName(anyString())).thenReturn(Optional.of(new Model()));
+ var actualModel = modelBusinessLogic.findModel("");
+ assertTrue(actualModel.isEmpty());
+ actualModel = modelBusinessLogic.findModel(null);
+ assertTrue(actualModel.isEmpty());
+ }
} \ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/path/beans/ToscaModelImportCassandraDaoMock.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/path/beans/ToscaModelImportCassandraDaoMock.java
new file mode 100644
index 0000000000..9f293b1a1c
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/path/beans/ToscaModelImportCassandraDaoMock.java
@@ -0,0 +1,39 @@
+/*
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2021 Nordix Foundation
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.components.path.beans;
+
+import javax.annotation.PostConstruct;
+import org.openecomp.sdc.be.dao.cassandra.CassandraClient;
+import org.openecomp.sdc.be.dao.cassandra.ToscaModelImportCassandraDao;
+import org.springframework.stereotype.Component;
+
+@Component("tosca-model-import-cassandra-dao")
+public class ToscaModelImportCassandraDaoMock extends ToscaModelImportCassandraDao {
+
+ public ToscaModelImportCassandraDaoMock(final CassandraClient cassandraClient) {
+ super(cassandraClient);
+ }
+
+ @PostConstruct
+ @Override
+ public void init() {
+
+ }
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ModelServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ModelServletTest.java
index 34201d3c1f..5992be4e9d 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ModelServletTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ModelServletTest.java
@@ -18,19 +18,28 @@
*/
package org.openecomp.sdc.be.servlets;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.when;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.InputStream;
+import java.nio.file.Path;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
-import javax.validation.ConstraintViolationException;
-import javax.ws.rs.core.Response;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response.Status;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jetty.http.HttpStatus;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.media.multipart.FormDataMultiPart;
+import org.glassfish.jersey.media.multipart.MultiPartFeature;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.glassfish.jersey.test.TestProperties;
@@ -46,6 +55,7 @@ import org.mockito.MockitoAnnotations;
import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ModelBusinessLogic;
import org.openecomp.sdc.be.components.impl.ResourceImportManager;
+import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
import org.openecomp.sdc.be.components.validation.UserValidations;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.config.SpringConfig;
@@ -55,6 +65,9 @@ import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.ServletUtils;
import org.openecomp.sdc.be.impl.WebAppContextWrapper;
import org.openecomp.sdc.be.model.Model;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
+import org.openecomp.sdc.be.servlets.builder.ServletResponseBuilder;
+import org.openecomp.sdc.be.servlets.exception.OperationExceptionMapper;
import org.openecomp.sdc.be.ui.model.ModelCreateRequest;
import org.openecomp.sdc.be.user.UserBusinessLogic;
import org.openecomp.sdc.common.api.ConfigurationSource;
@@ -100,13 +113,16 @@ class ModelServletTest extends JerseyTest {
@Mock
private UserValidations userValidations;
+ @Mock
+ private ResponseFormatManager responseFormatManager;
+
private Model model;
- private Response response;
private ModelCreateRequest modelCreateRequest;
+ private final Path rootPath = Path.of("/v1/catalog/model");
+ private final Path importsPath = rootPath.resolve("imports");
@BeforeAll
public void initClass() {
- MockitoAnnotations.openMocks(this);
when(request.getSession()).thenReturn(session);
when(session.getServletContext()).thenReturn(servletContext);
when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR))
@@ -145,6 +161,7 @@ class ModelServletTest extends JerseyTest {
@Override
protected ResourceConfig configure() {
+ MockitoAnnotations.openMocks(this);
forceSet(TestProperties.CONTAINER_PORT, "0");
final ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
return new ResourceConfig(ModelServlet.class)
@@ -158,51 +175,132 @@ class ModelServletTest extends JerseyTest {
bind(servletUtils).to(ServletUtils.class);
bind(resourceImportManager).to(ResourceImportManager.class);
bind(modelBusinessLogic).to(ModelBusinessLogic.class);
+ bind(userValidations).to(UserValidations.class);
}
})
+ .register(new OperationExceptionMapper(new ServletResponseBuilder(), responseFormatManager))
+ .register(MultiPartFeature.class)
.property("contextConfig", context);
}
+ @Override
+ protected void configureClient(final ClientConfig config) {
+ config.register(MultiPartFeature.class);
+ }
+
@Test
- void createModelSuccessTest() {
+ void createModelSuccessTest() throws JsonProcessingException {
when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200);
when(componentsUtils.getResponseFormat(ActionStatus.CREATED)).thenReturn(responseFormat);
when(modelBusinessLogic.createModel(any(Model.class))).thenReturn(model);
- response = modelServlet.createModel(modelCreateRequest, USER_ID);
- assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200);
+ final FormDataMultiPart formDataMultiPart = buildCreateFormDataMultiPart(new byte[0], parseToJsonString(modelCreateRequest));
+ final var response = target(rootPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .post(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.OK.getStatusCode(), response.getStatus());
}
@Test
- void createModelFailTest() {
+ void createModelFailTest() throws JsonProcessingException {
when(responseFormat.getStatus()).thenReturn(HttpStatus.INTERNAL_SERVER_ERROR_500);
when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(responseFormat);
when(modelBusinessLogic.createModel(any(Model.class))).thenReturn(model);
- response = modelServlet.createModel(modelCreateRequest, USER_ID);
- assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR_500);
+ final FormDataMultiPart formDataMultiPart = buildCreateFormDataMultiPart(new byte[0], parseToJsonString(modelCreateRequest));
+ final var response = target(rootPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .post(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
}
@Test
- void createModelFailWithModelNameEmptyTest() {
+ void createModelFailWithModelNameEmptyTest() throws JsonProcessingException {
when(responseFormat.getStatus()).thenReturn(HttpStatus.INTERNAL_SERVER_ERROR_500);
when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(responseFormat);
modelCreateRequest.setName(StringUtils.EMPTY);
- final Exception exception = assertThrows(ConstraintViolationException.class, () -> modelServlet.createModel(modelCreateRequest, USER_ID));
- assertThat(exception.getMessage()).isEqualTo("Model name cannot be empty");
+ final FormDataMultiPart formDataMultiPart = buildCreateFormDataMultiPart(new byte[0], parseToJsonString(modelCreateRequest));
+ final var response = target(rootPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .post(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus());
}
@Test
- void createModelFailWithModelNameNullTest() {
+ void createModelFailWithModelNameNullTest() throws JsonProcessingException {
when(responseFormat.getStatus()).thenReturn(HttpStatus.INTERNAL_SERVER_ERROR_500);
when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(responseFormat);
modelCreateRequest.setName(null);
- final Exception exception = assertThrows(ConstraintViolationException.class, () -> modelServlet.createModel(modelCreateRequest, USER_ID));
- assertThat(exception.getMessage()).isEqualTo("Model name cannot be null");
+ final var modelFile = new byte[0];
+ final FormDataMultiPart formDataMultiPart = buildCreateFormDataMultiPart(modelFile, parseToJsonString(modelCreateRequest));
+ final var response = target(rootPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .post(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus());
}
@Test
- void createModelThrowsBusinessExceptionTest() {
+ void createModelThrowsBusinessExceptionTest() throws JsonProcessingException {
+ final var modelFile = new byte[0];
+ final String modelCreateAsJson = parseToJsonString(modelCreateRequest);
+ final FormDataMultiPart formDataMultiPart = buildCreateFormDataMultiPart(modelFile, modelCreateAsJson);
when(modelBusinessLogic.createModel(model)).thenThrow(new BusinessException() {});
- assertThrows(BusinessException.class, () -> modelServlet.createModel(modelCreateRequest, USER_ID));
+
+ final var response = target(rootPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .post(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void updateModelImportsSuccessTest() {
+ final FormDataMultiPart formDataMultiPart = buildUpdateFormDataMultiPart("model1", new byte[0]);
+
+ final var response = target(importsPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .put(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void updateModelImports_businessException() {
+ final var modelId = "model1";
+ final FormDataMultiPart formDataMultiPart = buildUpdateFormDataMultiPart(modelId, new byte[0]);
+ final OperationException operationException = new OperationException(ActionStatus.INVALID_MODEL, modelId);
+ doThrow(operationException).when(modelBusinessLogic).createModelImports(eq(modelId), any(InputStream.class));
+ when(responseFormatManager.getResponseFormat(ActionStatus.INVALID_MODEL, modelId))
+ .thenReturn(new ResponseFormat(Status.BAD_REQUEST.getStatusCode()));
+ final var response = target(importsPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .put(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+ }
+
+ @Test
+ void updateModelImports_unknownException() {
+ final var modelName = "model1";
+ final FormDataMultiPart formDataMultiPart = buildUpdateFormDataMultiPart(modelName, new byte[0]);
+ doThrow(new RuntimeException()).when(modelBusinessLogic).createModelImports(eq(modelName), any(InputStream.class));
+ when(responseFormat.getStatus()).thenReturn(HttpStatus.INTERNAL_SERVER_ERROR_500);
+ when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(responseFormat);
+ final var response = target(importsPath.toString()).request(MediaType.APPLICATION_JSON)
+ .header(Constants.USER_ID_HEADER, USER_ID)
+ .put(Entity.entity(formDataMultiPart, MediaType.MULTIPART_FORM_DATA));
+ assertEquals(Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
+ }
+
+ private FormDataMultiPart buildUpdateFormDataMultiPart(final String modelName, final byte[] importFilesZip) {
+ return new FormDataMultiPart()
+ .field("modelName", modelName)
+ .field("modelImportsZip", importFilesZip, MediaType.MULTIPART_FORM_DATA_TYPE);
+ }
+
+ private FormDataMultiPart buildCreateFormDataMultiPart(final byte[] modelFile, final String modelCreateAsJson) {
+ return new FormDataMultiPart()
+ .field("model", modelCreateAsJson, MediaType.APPLICATION_JSON_TYPE)
+ .field("modelImportsZip", modelFile, MediaType.MULTIPART_FORM_DATA_TYPE);
+ }
+
+ private String parseToJsonString(final Object object) throws JsonProcessingException {
+ return new ObjectMapper().writeValueAsString(object);
}
} \ No newline at end of file