diff options
Diffstat (limited to 'catalog-be/src/test')
| -rw-r--r-- | catalog-be/src/test/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServletTest.java | 1006 |
1 files changed, 1006 insertions, 0 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServletTest.java new file mode 100644 index 0000000000..00f84ad9c9 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServletTest.java @@ -0,0 +1,1006 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2019 Nokia. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.externalapi.servlet; + +import fj.data.Either; +import org.apache.commons.text.StrSubstitutor; +import org.glassfish.hk2.utilities.binding.AbstractBinder; +import org.glassfish.jersey.server.ResourceConfig; +import org.glassfish.jersey.test.JerseyTest; +import org.junit.BeforeClass; +import org.junit.Test; +import org.mockito.Mockito; +import org.apache.http.HttpStatus; +import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic; +import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic; +import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic; +import org.openecomp.sdc.be.components.impl.ResourceImportManager; +import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException; +import org.openecomp.sdc.be.components.impl.exceptions.ComponentException; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.config.SpringConfig; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +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.ArtifactDefinition; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.user.Role; +import org.openecomp.sdc.be.user.UserBusinessLogic; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.api.Constants; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.openecomp.sdc.exception.ResponseFormat; +import org.springframework.context.ApplicationContext; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; +import org.springframework.web.context.WebApplicationContext; + +import javax.servlet.ServletContext; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpSession; +import javax.ws.rs.client.Entity; +import javax.ws.rs.core.Application; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.when; + +public class ArtifactExternalServletTest extends JerseyTest { + public static final HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + public static final HttpSession session = Mockito.mock(HttpSession.class); + public static final ResourceImportManager resourceImportManager = Mockito.mock(ResourceImportManager.class); + public static final ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class); + public static final Resource resource = Mockito.mock(Resource.class); + public static final UserBusinessLogic userBusinessLogic = Mockito.mock(UserBusinessLogic.class); + public static final ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class); + public static final ArtifactsBusinessLogic artifactsBusinessLogic = Mockito.mock(ArtifactsBusinessLogic.class); + + private static final ServletContext servletContext = Mockito.mock(ServletContext.class); + public static final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class); + private static final WebApplicationContext webApplicationContext = Mockito.mock(WebApplicationContext.class); + private static final ServletUtils servletUtils = Mockito.mock(ServletUtils.class); + private static final UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class); + private static final ComponentsUtils componentUtils = Mockito.mock(ComponentsUtils.class); + private static final ResponseFormat generalErrorResponseFormat = new ResponseFormat(HttpStatus.SC_INTERNAL_SERVER_ERROR); + private static final ResponseFormat unauthorizedResponseFormat = Mockito.mock(ResponseFormat.class); + private static final ResponseFormat notFoundResponseFormat = Mockito.mock(ResponseFormat.class); + private static final ResponseFormat badRequestResponseFormat = Mockito.mock(ResponseFormat.class); + private static final String ASSET_TYPE = "assetType"; + public static final String UUID = "uuid"; + private static final String RESOURCE_INSTANCE_NAME = "resourceInstanceName"; + private static final String INTERFACE_UUID = "interfaceUUID"; + private static final String OPERATION_UUID = "operationUUID"; + private static final String ARTIFACT_UUID = "artifactUUID"; + private static final String EMPTY_JSON = "{}"; + + /* Users */ + private static User designerUser = new User("designer", "designer", "designer", "designer@email.com", Role.DESIGNER.name(), System + .currentTimeMillis()); + + @BeforeClass + public static void setup() { + + //Needed for User Authorization + when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper); + when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webApplicationContext); + when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils); + when(servletUtils.getUserAdmin()).thenReturn(userAdmin); + when(servletUtils.getComponentsUtils()).thenReturn(componentUtils); + when(componentUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION)).thenReturn(unauthorizedResponseFormat); + when(unauthorizedResponseFormat.getStatus()).thenReturn(HttpStatus.SC_UNAUTHORIZED); + + ResponseFormat okResponseFormat = new ResponseFormat(org.apache.http.HttpStatus.SC_OK); + + when(componentUtils.getResponseFormat(ActionStatus.OK)) .thenReturn(okResponseFormat); + when(componentUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)).thenReturn(badRequestResponseFormat); + when(componentUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)) .thenReturn(generalErrorResponseFormat); + when(componentUtils.getResponseFormat(any(ComponentException.class))) + .thenReturn(generalErrorResponseFormat); + + ByResponseFormatComponentException ce = Mockito.mock(ByResponseFormatComponentException.class); + when(ce.getResponseFormat()).thenReturn(unauthorizedResponseFormat); + + //Needed for error configuration + when(notFoundResponseFormat.getStatus()).thenReturn(HttpStatus.SC_NOT_FOUND); + when(badRequestResponseFormat.getStatus()).thenReturn(HttpStatus.SC_BAD_REQUEST); + when(componentUtils.getResponseFormat(eq(ActionStatus.RESOURCE_NOT_FOUND), any())).thenReturn(notFoundResponseFormat); + when(componentUtils.getResponseFormat(eq(ActionStatus.COMPONENT_VERSION_NOT_FOUND), any())).thenReturn(notFoundResponseFormat); + when(componentUtils.getResponseFormat(eq(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND), any())).thenReturn(notFoundResponseFormat); + when(componentUtils.getResponseFormat(eq(ActionStatus.EXT_REF_NOT_FOUND), any())).thenReturn(notFoundResponseFormat); + when(componentUtils.getResponseFormat(eq(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID), any())).thenReturn(badRequestResponseFormat); + + Either<User, ActionStatus> designerEither = Either.left(designerUser); + + when(userAdmin.getUser(designerUser.getUserId(), false)).thenReturn(designerEither); + + String appConfigDir = "src/test/resources/config"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir); + ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); + + org.openecomp.sdc.be.config.Configuration configuration = new org.openecomp.sdc.be.config.Configuration(); + configuration.setJanusGraphInMemoryGraph(true); + + configurationManager.setConfiguration(configuration); + ExternalConfiguration.setAppName("catalog-be"); + } + + @Test + public void uploadInterfaceOperationArtifactNoInstanceIdHeaderTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, "assetType"); + parametersMap.put(UUID, "uuid"); + parametersMap.put(INTERFACE_UUID, "interfaceUUID"); + parametersMap.put(OPERATION_UUID, "operationUUID"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_BAD_REQUEST); + } + + @Test + public void uploadInterfaceOperationArtifactNoUserHeaderTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, "assetType"); + parametersMap.put(UUID, "uuid"); + parametersMap.put(INTERFACE_UUID, "interfaceUUID"); + parametersMap.put(OPERATION_UUID, "operationUUID"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void uploadInterfaceOperationArtifactTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, "assetType"); + parametersMap.put(UUID, "uuid"); + parametersMap.put(INTERFACE_UUID, "interfaceUUID"); + parametersMap.put(OPERATION_UUID, "operationUUID"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = Either.left(artifactDefinition); + when(artifactsBusinessLogic + .updateArtifactOnInterfaceOperationByResourceUUID(anyString(), any(), + any(), any(), any(), + any(), any(), any(), + any())) + .thenReturn(uploadArtifactEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void uploadInterfaceOperationArtifactFailedUploadTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, "assetType"); + parametersMap.put(UUID, "uuid"); + parametersMap.put(INTERFACE_UUID, "interfaceUUID"); + parametersMap.put(OPERATION_UUID, "operationUUID"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + when(artifactsBusinessLogic + .updateArtifactOnInterfaceOperationByResourceUUID(anyString(), any(), + any(), any(), any(), + any(), any(), any(), + any())) + .thenReturn(uploadArtifactEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void uploadInterfaceOperationArtifactExceptionDuringProcessingTest() { + String uuid = "uuidToThrow_uploadArtifact"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, "assetType"); + parametersMap.put(UUID, uuid); + parametersMap.put(INTERFACE_UUID, "interfaceUUID"); + parametersMap.put(OPERATION_UUID, "operationUUID"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + when(artifactsBusinessLogic + .updateArtifactOnInterfaceOperationByResourceUUID(anyString(), any(), + any(), any(), any(), + any(), any(), any(), + any())) + .thenThrow(new RuntimeException("Text exception")); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void uploadArtifactUnknownComponentTypeTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, "something_new"); + parametersMap.put(UUID, "uuid"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_BAD_REQUEST); + } + + @Test + public void uploadArtifactErrorDuringUploadProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + when(artifactsBusinessLogic + .uploadArtifactToComponentByUUID(anyString(), any(), any(), any(), any(), + any())) + .thenReturn(uploadArtifactEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void uploadArtifactExceptionDuringUploadTest() { + String uuid = "uuidToThrow_uploadArtifact"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.uploadArtifactToComponentByUUID(anyString(), any(), + any(), eq(uuid), any(), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void uploadArtifactTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = Either.left(artifactDefinition); + when(artifactsBusinessLogic + .uploadArtifactToComponentByUUID(anyString(), any(), any(), any(), any(), any())) + .thenReturn(uploadArtifactEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void uploadArtifactToInstanceErrorDuringUploadProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUIDEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + given(artifactsBusinessLogic.uploadArtifactToRiByUUID(anyString(), any(), + any(), any(), any(), any())) + .willAnswer( invocation -> uploadArtifactToRiByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void uploadArtifactToInstanceExceptionDuringUploadTest() { + String uuid = "uuidToThrow_uploadArtifactToInstance"; + String resourceInstanceName = "resourceInstanceNameToThrow_uploadArtifactToInstance"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.uploadArtifactToRiByUUID(anyString(), any(), + any(), eq(uuid), eq(resourceInstanceName), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void uploadArtifactToInstanceTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUIDEither = Either.left(artifactDefinition); + + given(artifactsBusinessLogic.uploadArtifactToRiByUUID(anyString(), any(), + any(), any(), any(), any())) + .willAnswer( invocation -> uploadArtifactToRiByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void updateArtifactErrorDuringUpdateProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<ArtifactDefinition, ResponseFormat> updateArtifactEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + given(artifactsBusinessLogic.updateArtifactOnComponentByUUID(anyString(), any(), + any(), any(), any(), any(), any())) + .willAnswer( invocation -> updateArtifactEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void updateArtifactExceptionDuringUpdateTest() { + String uuid = "uuidToThrow_updateArtifact"; + String artifactUUID = "artifactUUIDToThrow_updateArtifact"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(ARTIFACT_UUID, artifactUUID); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.updateArtifactOnComponentByUUID(anyString(), any(), + any(), eq(uuid), eq(artifactUUID), any(), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void updateArtifactTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUIDEither = Either.left(artifactDefinition); + + given(artifactsBusinessLogic.updateArtifactOnComponentByUUID(anyString(), any(), + any(), any(), any(), any(), any())) + .willAnswer( invocation -> uploadArtifactToRiByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + ///////////////////////// + + @Test + public void updateArtifactOnResourceInstanceErrorDuringUpdateProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<ArtifactDefinition, ResponseFormat> updateArtifactOnResourceInstanceEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + given(artifactsBusinessLogic.updateArtifactOnRiByUUID(anyString(), any(), + any(), any(), any(), any(), any())) + .willAnswer( invocation -> updateArtifactOnResourceInstanceEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void updateArtifactOnResourceInstanceExceptionDuringUpdateTest() { + String uuid = "uuidToThrow_updateArtifactOnResourceInstance"; + String resourceInstanceName = "resourceInstanceNameToThrow_updateArtifactOnResourceInstance"; + String artifactUUID = "artifactUUIDToThrow_updateArtifactOnResourceInstance"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName); + parametersMap.put(ARTIFACT_UUID, artifactUUID); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.updateArtifactOnRiByUUID(anyString(), any(), + any(), eq(uuid), eq(resourceInstanceName), eq(artifactUUID), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void updateArtifactOnResourceInstanceTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> updateArtifactOnResourceInstanceEither = Either.left(artifactDefinition); + + given(artifactsBusinessLogic.updateArtifactOnRiByUUID(anyString(), any(), + any(), any(), any(), any(), any())) + .willAnswer( invocation -> updateArtifactOnResourceInstanceEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .post(Entity.json(EMPTY_JSON)); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void deleteArtifactErrorDuringDeleteProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnComponentByUUIDEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + given(artifactsBusinessLogic.deleteArtifactOnComponentByUUID(any(), any(), any(), any(), + any(), any())) + .willAnswer( invocation -> deleteArtifactOnComponentByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .delete(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void deleteArtifactExceptionDuringDeleteTest() { + String uuid = "uuidToThrow_deleteArtifact"; + String artifactUUID = "artifactUUIDToThrow_deleteArtifact"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(ARTIFACT_UUID, artifactUUID); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.deleteArtifactOnComponentByUUID(any(), any(), eq(uuid), + eq(artifactUUID), any(), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .delete(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void deleteArtifactTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnComponentByUUIDEither = Either.left(artifactDefinition); + + given(artifactsBusinessLogic.deleteArtifactOnComponentByUUID(any(), any(), any(), any(), + any(), any())) + .willAnswer( invocation -> deleteArtifactOnComponentByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .delete(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void deleteArtifactOnResourceErrorDuringDeleteProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnRiByUUIDEither = + Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT)); + + given(artifactsBusinessLogic.deleteArtifactOnRiByUUID(any(), any(), any(), any(), + any(), any())) + .willAnswer( invocation -> deleteArtifactOnRiByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .delete(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT); + } + + @Test + public void deleteArtifactOnResourceExceptionDuringDeleteTest() { + String uuid = "uuidToThrow_deleteArtifactOnResource"; + String resourceInstanceName = "resourceInstanceNameToThrow_deleteArtifactOnResource"; + String artifactUUID = "artifactUUIDToThrow_deleteArtifactOnResource"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName); + parametersMap.put(ARTIFACT_UUID, artifactUUID); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.deleteArtifactOnRiByUUID(any(), any(), eq(uuid), + eq(resourceInstanceName), eq(artifactUUID), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .delete(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void deleteArtifactOnResourceTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + ArtifactDefinition artifactDefinition = new ArtifactDefinition(); + Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnRiByUUIDEither = Either.left(artifactDefinition); + + given(artifactsBusinessLogic.deleteArtifactOnRiByUUID(any(), any(), any(), any(), + any(), any())) + .willAnswer( invocation -> deleteArtifactOnRiByUUIDEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_JSON) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .delete(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void downloadComponentArtifactErrorDuringDownloadProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<byte[], ResponseFormat> downloadComponentArtifactByUUIDsEither = + Either.right(new ResponseFormat(HttpStatus.SC_SERVICE_UNAVAILABLE)); + + given(artifactsBusinessLogic.downloadComponentArtifactByUUIDs(any(), any(), any(), any())) + .willAnswer( invocation -> downloadComponentArtifactByUUIDsEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_OCTET_STREAM) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .get(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_SERVICE_UNAVAILABLE); + } + + @Test + public void downloadComponentArtifactExceptionDuringUploadTest() { + String uuid = "uuidToThrow_downloadComponentArtifact"; + String artifactUUID = "artifactUUIDToThrow_downloadComponentArtifact"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(ARTIFACT_UUID, artifactUUID); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + given(artifactsBusinessLogic.downloadComponentArtifactByUUIDs(any(), eq(uuid), + eq(artifactUUID), any())) + .willAnswer( invocation -> { throw new IOException("Test exception"); }); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_OCTET_STREAM) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .get(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void downloadComponentArtifactTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + byte[] responsePayload = {0xA, 0xB, 0xC, 0xD}; + Either<byte[], ResponseFormat> downloadComponentArtifactByUUIDsEither = Either.left(responsePayload); + + given(artifactsBusinessLogic.downloadComponentArtifactByUUIDs(any(), any(), any(), any())) + .willAnswer( invocation -> downloadComponentArtifactByUUIDsEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_OCTET_STREAM) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .get(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Test + public void downloadResourceInstanceArtifactErrorDuringDownloadProcessingTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + Either<byte[], ResponseFormat> downloadResourceInstanceArtifactByUUIDsEither = + Either.right(new ResponseFormat(HttpStatus.SC_SERVICE_UNAVAILABLE)); + + given(artifactsBusinessLogic.downloadResourceInstanceArtifactByUUIDs(any(), any(), any(), + any())) + .willAnswer( invocation -> downloadResourceInstanceArtifactByUUIDsEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_OCTET_STREAM) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .get(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_SERVICE_UNAVAILABLE); + } + + @Test + public void downloadResourceInstanceArtifactExceptionDuringUploadTest() { + String uuid = "uuidToThrow_downloadResourceInstanceArtifact"; + String resourceInstanceName = "resourceInstanceNameToThrow_downloadResourceInstanceArtifact"; + String artifactUUID = "artifactUUIDToThrow_downloadResourceInstanceArtifact"; + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, uuid); + parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName); + parametersMap.put(ARTIFACT_UUID, artifactUUID); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + when(artifactsBusinessLogic.downloadResourceInstanceArtifactByUUIDs(any(), eq(uuid), + eq(resourceInstanceName), eq(artifactUUID))) + .thenThrow(new ByResponseFormatComponentException(generalErrorResponseFormat)); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_OCTET_STREAM) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .get(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + } + + @Test + public void downloadResourceInstanceArtifactTest() { + Map<String,String> parametersMap = new HashMap<>(); + parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME); + parametersMap.put(UUID, "uuid"); + parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName"); + parametersMap.put(ARTIFACT_UUID, "artifactUUID"); + + String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}"; + String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}"); + + byte[] responsePayload = {0xA, 0xB, 0xC, 0xD}; + Either<byte[], ResponseFormat> downloadResourceInstanceArtifactByUUIDsEither = Either.left(responsePayload); + + given(artifactsBusinessLogic.downloadResourceInstanceArtifactByUUIDs(any(), any(), any(), + any())) + .willAnswer( invocation -> downloadResourceInstanceArtifactByUUIDsEither); + + Response response = target() + .path(path) + .request() + .accept(MediaType.APPLICATION_OCTET_STREAM) + .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId") + .header(Constants.USER_ID_HEADER, designerUser.getUserId()) + .get(); + + assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK); + } + + @Override + protected Application configure() { + ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); + return new ResourceConfig(ArtifactExternalServlet.class) + .register(new AbstractBinder() { + + @Override + protected void configure() { + bind(request).to(HttpServletRequest.class); + bind(userBusinessLogic).to(UserBusinessLogic.class); + bind(componentInstanceBusinessLogic).to(ComponentInstanceBusinessLogic.class); + bind(componentUtils).to(ComponentsUtils.class); + bind(servletUtils).to(ServletUtils.class); + bind(resourceImportManager).to(ResourceImportManager.class); + bind(artifactsBusinessLogic).to(ArtifactsBusinessLogic.class); + } + }) + .property("contextConfig", context); + } +}
\ No newline at end of file |