catalog-be/src/test/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServletTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 Nokia. 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.externalapi.servlet;
  22
  23 import fj.data.Either;
  24 import org.apache.commons.text.StrSubstitutor;
  25 import org.glassfish.hk2.utilities.binding.AbstractBinder;
  26 import org.glassfish.jersey.server.ResourceConfig;
  27 import org.glassfish.jersey.test.JerseyTest;
  28 import org.junit.BeforeClass;
  29 import org.junit.Test;
  30 import org.mockito.Mockito;
  31 import org.apache.http.HttpStatus;
  32 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
  33 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  34 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  35 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  36 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  37 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  38 import org.openecomp.sdc.be.config.ConfigurationManager;
  39 import org.openecomp.sdc.be.config.SpringConfig;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  42 import org.openecomp.sdc.be.impl.ComponentsUtils;
  43 import org.openecomp.sdc.be.impl.ServletUtils;
  44 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  45 import org.openecomp.sdc.be.model.ArtifactDefinition;
  46 import org.openecomp.sdc.be.model.Resource;
  47 import org.openecomp.sdc.be.model.User;
  48 import org.openecomp.sdc.be.user.Role;
  49 import org.openecomp.sdc.be.user.UserBusinessLogic;
  50 import org.openecomp.sdc.common.api.ConfigurationSource;
  51 import org.openecomp.sdc.common.api.Constants;
  52 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  53 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  54 import org.openecomp.sdc.exception.ResponseFormat;
  55 import org.springframework.context.ApplicationContext;
  56 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  57 import org.springframework.web.context.WebApplicationContext;
  58
  59 import javax.servlet.ServletContext;
  60 import javax.servlet.http.HttpServletRequest;
  61 import javax.servlet.http.HttpSession;
  62 import javax.ws.rs.client.Entity;
  63 import javax.ws.rs.core.Application;
  64 import javax.ws.rs.core.MediaType;
  65 import javax.ws.rs.core.Response;
  66 import java.io.IOException;
  67 import java.util.HashMap;
  68 import java.util.Map;
  69
  70 import static org.assertj.core.api.Assertions.assertThat;
  71 import static org.mockito.ArgumentMatchers.any;
  72 import static org.mockito.ArgumentMatchers.anyString;
  73 import static org.mockito.ArgumentMatchers.eq;
  74 import static org.mockito.BDDMockito.given;
  75 import static org.mockito.Mockito.when;
  76
  77 public class ArtifactExternalServletTest extends JerseyTest {
  78     public static final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
  79     public static final HttpSession session = Mockito.mock(HttpSession.class);
  80     public static final ResourceImportManager resourceImportManager = Mockito.mock(ResourceImportManager.class);
  81     public static final ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class);
  82     public static final Resource resource = Mockito.mock(Resource.class);
  83     public static final UserBusinessLogic userBusinessLogic = Mockito.mock(UserBusinessLogic.class);
  84     public static final ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
  85     public static final ArtifactsBusinessLogic artifactsBusinessLogic = Mockito.mock(ArtifactsBusinessLogic.class);
  86
  87     private static final ServletContext servletContext = Mockito.mock(ServletContext.class);
  88     public static final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
  89     private static final WebApplicationContext webApplicationContext = Mockito.mock(WebApplicationContext.class);
  90     private static final ServletUtils servletUtils = Mockito.mock(ServletUtils.class);
  91     private static final UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class);
  92     private static final ComponentsUtils componentUtils = Mockito.mock(ComponentsUtils.class);
  93     private static final ResponseFormat generalErrorResponseFormat = new ResponseFormat(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  94     private static final ResponseFormat unauthorizedResponseFormat = Mockito.mock(ResponseFormat.class);
  95     private static final ResponseFormat notFoundResponseFormat = Mockito.mock(ResponseFormat.class);
  96     private static final ResponseFormat badRequestResponseFormat = Mockito.mock(ResponseFormat.class);
  97     private static final String ASSET_TYPE = "assetType";
  98     public static final String UUID = "uuid";
  99     private static final String RESOURCE_INSTANCE_NAME = "resourceInstanceName";
 100     private static final String INTERFACE_UUID = "interfaceUUID";
 101     private static final String OPERATION_UUID = "operationUUID";
 102     private static final String ARTIFACT_UUID = "artifactUUID";
 103     private static final String EMPTY_JSON = "{}";
 104
 105     /* Users */
 106     private static User designerUser = new User("designer", "designer", "designer", "designer@email.com", Role.DESIGNER.name(), System
 107             .currentTimeMillis());
 108
 109     @BeforeClass
 110     public static void setup() {
 111
 112         //Needed for User Authorization
 113         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 114         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webApplicationContext);
 115         when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils);
 116         when(servletUtils.getUserAdmin()).thenReturn(userAdmin);
 117         when(servletUtils.getComponentsUtils()).thenReturn(componentUtils);
 118         when(componentUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION)).thenReturn(unauthorizedResponseFormat);
 119         when(unauthorizedResponseFormat.getStatus()).thenReturn(HttpStatus.SC_UNAUTHORIZED);
 120
 121         ResponseFormat okResponseFormat = new ResponseFormat(org.apache.http.HttpStatus.SC_OK);
 122
 123         when(componentUtils.getResponseFormat(ActionStatus.OK)) .thenReturn(okResponseFormat);
 124         when(componentUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)).thenReturn(badRequestResponseFormat);
 125         when(componentUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)) .thenReturn(generalErrorResponseFormat);
 126         when(componentUtils.getResponseFormat(any(ComponentException.class)))
 127                 .thenReturn(generalErrorResponseFormat);
 128
 129         ByResponseFormatComponentException ce = Mockito.mock(ByResponseFormatComponentException.class);
 130         when(ce.getResponseFormat()).thenReturn(unauthorizedResponseFormat);
 131
 132         //Needed for error configuration
 133         when(notFoundResponseFormat.getStatus()).thenReturn(HttpStatus.SC_NOT_FOUND);
 134         when(badRequestResponseFormat.getStatus()).thenReturn(HttpStatus.SC_BAD_REQUEST);
 135         when(componentUtils.getResponseFormat(eq(ActionStatus.RESOURCE_NOT_FOUND), any())).thenReturn(notFoundResponseFormat);
 136         when(componentUtils.getResponseFormat(eq(ActionStatus.COMPONENT_VERSION_NOT_FOUND), any())).thenReturn(notFoundResponseFormat);
 137         when(componentUtils.getResponseFormat(eq(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND), any())).thenReturn(notFoundResponseFormat);
 138         when(componentUtils.getResponseFormat(eq(ActionStatus.EXT_REF_NOT_FOUND), any())).thenReturn(notFoundResponseFormat);
 139         when(componentUtils.getResponseFormat(eq(ActionStatus.MISSING_X_ECOMP_INSTANCE_ID), any())).thenReturn(badRequestResponseFormat);
 140
 141         Either<User, ActionStatus> designerEither = Either.left(designerUser);
 142
 143         when(userAdmin.getUser(designerUser.getUserId(), false)).thenReturn(designerEither);
 144
 145         String appConfigDir = "src/test/resources/config";
 146         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 147         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 148
 149         org.openecomp.sdc.be.config.Configuration configuration = new org.openecomp.sdc.be.config.Configuration();
 150         configuration.setJanusGraphInMemoryGraph(true);
 151
 152         configurationManager.setConfiguration(configuration);
 153         ExternalConfiguration.setAppName("catalog-be");
 154     }
 155
 156     @Test
 157     public void uploadInterfaceOperationArtifactNoInstanceIdHeaderTest() {
 158         Map<String,String> parametersMap = new HashMap<>();
 159         parametersMap.put(ASSET_TYPE, "assetType");
 160         parametersMap.put(UUID, "uuid");
 161         parametersMap.put(INTERFACE_UUID, "interfaceUUID");
 162         parametersMap.put(OPERATION_UUID, "operationUUID");
 163         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 164
 165         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}";
 166         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 167
 168         Response response = target()
 169                 .path(path)
 170                 .request()
 171                 .accept(MediaType.APPLICATION_JSON)
 172                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 173                 .post(Entity.json(EMPTY_JSON));
 174
 175         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_BAD_REQUEST);
 176     }
 177
 178     @Test
 179     public void uploadInterfaceOperationArtifactNoUserHeaderTest() {
 180         Map<String,String> parametersMap = new HashMap<>();
 181         parametersMap.put(ASSET_TYPE, "assetType");
 182         parametersMap.put(UUID, "uuid");
 183         parametersMap.put(INTERFACE_UUID, "interfaceUUID");
 184         parametersMap.put(OPERATION_UUID, "operationUUID");
 185         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 186
 187         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}";
 188         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 189
 190         Response response = target()
 191                 .path(path)
 192                 .request()
 193                 .accept(MediaType.APPLICATION_JSON)
 194                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 195                 .post(Entity.json(EMPTY_JSON));
 196
 197         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 198     }
 199
 200     @Test
 201     public void uploadInterfaceOperationArtifactTest() {
 202         Map<String,String> parametersMap = new HashMap<>();
 203         parametersMap.put(ASSET_TYPE, "assetType");
 204         parametersMap.put(UUID, "uuid");
 205         parametersMap.put(INTERFACE_UUID, "interfaceUUID");
 206         parametersMap.put(OPERATION_UUID, "operationUUID");
 207         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 208
 209         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}";
 210         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 211
 212         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 213         Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = Either.left(artifactDefinition);
 214         when(artifactsBusinessLogic
 215                 .updateArtifactOnInterfaceOperationByResourceUUID(anyString(), any(),
 216                         any(), any(), any(),
 217                         any(), any(), any(),
 218                         any()))
 219                 .thenReturn(uploadArtifactEither);
 220
 221         Response response = target()
 222                 .path(path)
 223                 .request()
 224                 .accept(MediaType.APPLICATION_JSON)
 225                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 226                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 227                 .post(Entity.json(EMPTY_JSON));
 228
 229         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 230     }
 231
 232     @Test
 233     public void uploadInterfaceOperationArtifactFailedUploadTest() {
 234         Map<String,String> parametersMap = new HashMap<>();
 235         parametersMap.put(ASSET_TYPE, "assetType");
 236         parametersMap.put(UUID, "uuid");
 237         parametersMap.put(INTERFACE_UUID, "interfaceUUID");
 238         parametersMap.put(OPERATION_UUID, "operationUUID");
 239         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 240
 241         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}";
 242         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 243         Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither =
 244                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 245
 246         when(artifactsBusinessLogic
 247                 .updateArtifactOnInterfaceOperationByResourceUUID(anyString(), any(),
 248                         any(), any(), any(),
 249                         any(), any(), any(),
 250                         any()))
 251                 .thenReturn(uploadArtifactEither);
 252
 253         Response response = target()
 254                 .path(path)
 255                 .request()
 256                 .accept(MediaType.APPLICATION_JSON)
 257                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 258                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 259                 .post(Entity.json(EMPTY_JSON));
 260
 261         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 262     }
 263
 264     @Test
 265     public void uploadInterfaceOperationArtifactExceptionDuringProcessingTest() {
 266         String uuid = "uuidToThrow_uploadArtifact";
 267         Map<String,String> parametersMap = new HashMap<>();
 268         parametersMap.put(ASSET_TYPE, "assetType");
 269         parametersMap.put(UUID, uuid);
 270         parametersMap.put(INTERFACE_UUID, "interfaceUUID");
 271         parametersMap.put(OPERATION_UUID, "operationUUID");
 272         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 273
 274         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}";
 275         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 276
 277         when(artifactsBusinessLogic
 278                 .updateArtifactOnInterfaceOperationByResourceUUID(anyString(), any(),
 279                         any(), any(), any(),
 280                         any(), any(), any(),
 281                         any()))
 282                 .thenThrow(new RuntimeException("Text exception"));
 283
 284         Response response = target()
 285                 .path(path)
 286                 .request()
 287                 .accept(MediaType.APPLICATION_JSON)
 288                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 289                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 290                 .post(Entity.json(EMPTY_JSON));
 291
 292         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 293     }
 294
 295     @Test
 296     public void uploadArtifactUnknownComponentTypeTest() {
 297         Map<String,String> parametersMap = new HashMap<>();
 298         parametersMap.put(ASSET_TYPE, "something_new");
 299         parametersMap.put(UUID, "uuid");
 300
 301         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts";
 302         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 303
 304         Response response = target()
 305                 .path(path)
 306                 .request()
 307                 .accept(MediaType.APPLICATION_JSON)
 308                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 309                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 310                 .post(Entity.json(EMPTY_JSON));
 311
 312         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_BAD_REQUEST);
 313     }
 314
 315     @Test
 316     public void uploadArtifactErrorDuringUploadProcessingTest() {
 317         Map<String,String> parametersMap = new HashMap<>();
 318         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 319         parametersMap.put(UUID, "uuid");
 320
 321         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts";
 322         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 323
 324         Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither =
 325                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 326
 327         when(artifactsBusinessLogic
 328                 .uploadArtifactToComponentByUUID(anyString(), any(), any(), any(),  any(),
 329                         any()))
 330                 .thenReturn(uploadArtifactEither);
 331
 332         Response response = target()
 333                 .path(path)
 334                 .request()
 335                 .accept(MediaType.APPLICATION_JSON)
 336                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 337                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 338                 .post(Entity.json(EMPTY_JSON));
 339
 340         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 341     }
 342
 343     @Test
 344     public void uploadArtifactExceptionDuringUploadTest() {
 345         String uuid = "uuidToThrow_uploadArtifact";
 346         Map<String,String> parametersMap = new HashMap<>();
 347         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 348         parametersMap.put(UUID, uuid);
 349
 350         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts";
 351         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 352
 353         given(artifactsBusinessLogic.uploadArtifactToComponentByUUID(anyString(), any(),
 354                 any(), eq(uuid), any(), any()))
 355                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 356
 357         Response response = target()
 358                 .path(path)
 359                 .request()
 360                 .accept(MediaType.APPLICATION_JSON)
 361                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 362                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 363                 .post(Entity.json(EMPTY_JSON));
 364
 365         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 366     }
 367
 368     @Test
 369     public void uploadArtifactTest() {
 370         Map<String,String> parametersMap = new HashMap<>();
 371         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 372         parametersMap.put(UUID, "uuid");
 373
 374         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts";
 375         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 376
 377         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 378         Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = Either.left(artifactDefinition);
 379         when(artifactsBusinessLogic
 380                 .uploadArtifactToComponentByUUID(anyString(), any(), any(), any(), any(), any()))
 381                 .thenReturn(uploadArtifactEither);
 382
 383         Response response = target()
 384                 .path(path)
 385                 .request()
 386                 .accept(MediaType.APPLICATION_JSON)
 387                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 388                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 389                 .post(Entity.json(EMPTY_JSON));
 390
 391         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 392     }
 393
 394     @Test
 395     public void uploadArtifactToInstanceErrorDuringUploadProcessingTest() {
 396         Map<String,String> parametersMap = new HashMap<>();
 397         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 398         parametersMap.put(UUID, "uuid");
 399         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 400
 401         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts";
 402         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 403
 404         Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUIDEither =
 405                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 406
 407         given(artifactsBusinessLogic.uploadArtifactToRiByUUID(anyString(), any(),
 408                 any(), any(), any(), any()))
 409                 .willAnswer( invocation -> uploadArtifactToRiByUUIDEither);
 410
 411         Response response = target()
 412                 .path(path)
 413                 .request()
 414                 .accept(MediaType.APPLICATION_JSON)
 415                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 416                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 417                 .post(Entity.json(EMPTY_JSON));
 418
 419         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 420     }
 421
 422     @Test
 423     public void uploadArtifactToInstanceExceptionDuringUploadTest() {
 424         String uuid = "uuidToThrow_uploadArtifactToInstance";
 425         String resourceInstanceName = "resourceInstanceNameToThrow_uploadArtifactToInstance";
 426         Map<String,String> parametersMap = new HashMap<>();
 427         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 428         parametersMap.put(UUID, uuid);
 429         parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName);
 430
 431         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts";
 432         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 433
 434         given(artifactsBusinessLogic.uploadArtifactToRiByUUID(anyString(), any(),
 435                 any(), eq(uuid), eq(resourceInstanceName), any()))
 436                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 437
 438         Response response = target()
 439                 .path(path)
 440                 .request()
 441                 .accept(MediaType.APPLICATION_JSON)
 442                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 443                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 444                 .post(Entity.json(EMPTY_JSON));
 445
 446         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 447     }
 448
 449     @Test
 450     public void uploadArtifactToInstanceTest() {
 451         Map<String,String> parametersMap = new HashMap<>();
 452         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 453         parametersMap.put(UUID, "uuid");
 454         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 455
 456         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts";
 457         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 458
 459         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 460         Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUIDEither = Either.left(artifactDefinition);
 461
 462         given(artifactsBusinessLogic.uploadArtifactToRiByUUID(anyString(), any(),
 463                 any(), any(), any(), any()))
 464                 .willAnswer( invocation -> uploadArtifactToRiByUUIDEither);
 465
 466         Response response = target()
 467                 .path(path)
 468                 .request()
 469                 .accept(MediaType.APPLICATION_JSON)
 470                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 471                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 472                 .post(Entity.json(EMPTY_JSON));
 473
 474         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 475     }
 476
 477     @Test
 478     public void updateArtifactErrorDuringUpdateProcessingTest() {
 479         Map<String,String> parametersMap = new HashMap<>();
 480         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 481         parametersMap.put(UUID, "uuid");
 482         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 483
 484         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 485         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 486
 487         Either<ArtifactDefinition, ResponseFormat> updateArtifactEither =
 488                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 489
 490         given(artifactsBusinessLogic.updateArtifactOnComponentByUUID(anyString(), any(),
 491                 any(), any(), any(), any(), any()))
 492                 .willAnswer( invocation -> updateArtifactEither);
 493
 494         Response response = target()
 495                 .path(path)
 496                 .request()
 497                 .accept(MediaType.APPLICATION_JSON)
 498                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 499                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 500                 .post(Entity.json(EMPTY_JSON));
 501
 502         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 503     }
 504
 505     @Test
 506     public void updateArtifactExceptionDuringUpdateTest() {
 507         String uuid = "uuidToThrow_updateArtifact";
 508         String artifactUUID = "artifactUUIDToThrow_updateArtifact";
 509         Map<String,String> parametersMap = new HashMap<>();
 510         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 511         parametersMap.put(UUID, uuid);
 512         parametersMap.put(ARTIFACT_UUID, artifactUUID);
 513
 514         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 515         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 516
 517         given(artifactsBusinessLogic.updateArtifactOnComponentByUUID(anyString(), any(),
 518                 any(), eq(uuid), eq(artifactUUID), any(), any()))
 519                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 520
 521         Response response = target()
 522                 .path(path)
 523                 .request()
 524                 .accept(MediaType.APPLICATION_JSON)
 525                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 526                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 527                 .post(Entity.json(EMPTY_JSON));
 528
 529         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 530     }
 531
 532     @Test
 533     public void updateArtifactTest() {
 534         Map<String,String> parametersMap = new HashMap<>();
 535         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 536         parametersMap.put(UUID, "uuid");
 537         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 538
 539         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 540         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 541
 542         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 543         Either<ArtifactDefinition, ResponseFormat> uploadArtifactToRiByUUIDEither = Either.left(artifactDefinition);
 544
 545         given(artifactsBusinessLogic.updateArtifactOnComponentByUUID(anyString(), any(),
 546                 any(), any(), any(), any(), any()))
 547                 .willAnswer( invocation -> uploadArtifactToRiByUUIDEither);
 548
 549         Response response = target()
 550                 .path(path)
 551                 .request()
 552                 .accept(MediaType.APPLICATION_JSON)
 553                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 554                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 555                 .post(Entity.json(EMPTY_JSON));
 556
 557         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 558     }
 559
 560     /////////////////////////
 561
 562     @Test
 563     public void updateArtifactOnResourceInstanceErrorDuringUpdateProcessingTest() {
 564         Map<String,String> parametersMap = new HashMap<>();
 565         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 566         parametersMap.put(UUID, "uuid");
 567         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 568         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 569
 570         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 571         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 572
 573         Either<ArtifactDefinition, ResponseFormat> updateArtifactOnResourceInstanceEither =
 574                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 575
 576         given(artifactsBusinessLogic.updateArtifactOnRiByUUID(anyString(), any(),
 577                 any(), any(), any(), any(), any()))
 578                 .willAnswer( invocation -> updateArtifactOnResourceInstanceEither);
 579
 580         Response response = target()
 581                 .path(path)
 582                 .request()
 583                 .accept(MediaType.APPLICATION_JSON)
 584                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 585                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 586                 .post(Entity.json(EMPTY_JSON));
 587
 588         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 589     }
 590
 591     @Test
 592     public void updateArtifactOnResourceInstanceExceptionDuringUpdateTest() {
 593         String uuid = "uuidToThrow_updateArtifactOnResourceInstance";
 594         String resourceInstanceName = "resourceInstanceNameToThrow_updateArtifactOnResourceInstance";
 595         String artifactUUID = "artifactUUIDToThrow_updateArtifactOnResourceInstance";
 596         Map<String,String> parametersMap = new HashMap<>();
 597         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 598         parametersMap.put(UUID, uuid);
 599         parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName);
 600         parametersMap.put(ARTIFACT_UUID, artifactUUID);
 601
 602         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 603         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 604
 605         given(artifactsBusinessLogic.updateArtifactOnRiByUUID(anyString(), any(),
 606                 any(), eq(uuid), eq(resourceInstanceName), eq(artifactUUID), any()))
 607                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 608
 609         Response response = target()
 610                 .path(path)
 611                 .request()
 612                 .accept(MediaType.APPLICATION_JSON)
 613                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 614                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 615                 .post(Entity.json(EMPTY_JSON));
 616
 617         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 618     }
 619
 620     @Test
 621     public void updateArtifactOnResourceInstanceTest() {
 622         Map<String,String> parametersMap = new HashMap<>();
 623         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 624         parametersMap.put(UUID, "uuid");
 625         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 626         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 627
 628         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 629         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 630
 631         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 632         Either<ArtifactDefinition, ResponseFormat> updateArtifactOnResourceInstanceEither = Either.left(artifactDefinition);
 633
 634         given(artifactsBusinessLogic.updateArtifactOnRiByUUID(anyString(), any(),
 635                 any(), any(), any(), any(), any()))
 636                 .willAnswer( invocation -> updateArtifactOnResourceInstanceEither);
 637
 638         Response response = target()
 639                 .path(path)
 640                 .request()
 641                 .accept(MediaType.APPLICATION_JSON)
 642                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 643                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 644                 .post(Entity.json(EMPTY_JSON));
 645
 646         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 647     }
 648
 649     @Test
 650     public void deleteArtifactErrorDuringDeleteProcessingTest() {
 651         Map<String,String> parametersMap = new HashMap<>();
 652         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 653         parametersMap.put(UUID, "uuid");
 654         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 655
 656         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 657         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 658
 659         Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnComponentByUUIDEither =
 660                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 661
 662         given(artifactsBusinessLogic.deleteArtifactOnComponentByUUID(any(), any(), any(), any(),
 663                 any(), any()))
 664                 .willAnswer( invocation -> deleteArtifactOnComponentByUUIDEither);
 665
 666         Response response = target()
 667                 .path(path)
 668                 .request()
 669                 .accept(MediaType.APPLICATION_JSON)
 670                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 671                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 672                 .delete();
 673
 674         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 675     }
 676
 677     @Test
 678     public void deleteArtifactExceptionDuringDeleteTest() {
 679         String uuid = "uuidToThrow_deleteArtifact";
 680         String artifactUUID = "artifactUUIDToThrow_deleteArtifact";
 681         Map<String,String> parametersMap = new HashMap<>();
 682         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 683         parametersMap.put(UUID, uuid);
 684         parametersMap.put(ARTIFACT_UUID, artifactUUID);
 685
 686         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 687         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 688
 689         given(artifactsBusinessLogic.deleteArtifactOnComponentByUUID(any(), any(), eq(uuid),
 690                 eq(artifactUUID), any(), any()))
 691                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 692
 693         Response response = target()
 694                 .path(path)
 695                 .request()
 696                 .accept(MediaType.APPLICATION_JSON)
 697                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 698                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 699                 .delete();
 700
 701         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 702     }
 703
 704     @Test
 705     public void deleteArtifactTest() {
 706         Map<String,String> parametersMap = new HashMap<>();
 707         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 708         parametersMap.put(UUID, "uuid");
 709         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 710
 711         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 712         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 713
 714         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 715         Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnComponentByUUIDEither = Either.left(artifactDefinition);
 716
 717         given(artifactsBusinessLogic.deleteArtifactOnComponentByUUID(any(), any(), any(), any(),
 718                 any(), any()))
 719                 .willAnswer( invocation -> deleteArtifactOnComponentByUUIDEither);
 720
 721         Response response = target()
 722                 .path(path)
 723                 .request()
 724                 .accept(MediaType.APPLICATION_JSON)
 725                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 726                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 727                 .delete();
 728
 729         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 730     }
 731
 732     @Test
 733     public void deleteArtifactOnResourceErrorDuringDeleteProcessingTest() {
 734         Map<String,String> parametersMap = new HashMap<>();
 735         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 736         parametersMap.put(UUID, "uuid");
 737         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 738         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 739
 740         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 741         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 742
 743         Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnRiByUUIDEither =
 744                 Either.right(new ResponseFormat(HttpStatus.SC_CONFLICT));
 745
 746         given(artifactsBusinessLogic.deleteArtifactOnRiByUUID(any(), any(), any(), any(),
 747                 any(), any()))
 748                 .willAnswer( invocation -> deleteArtifactOnRiByUUIDEither);
 749
 750         Response response = target()
 751                 .path(path)
 752                 .request()
 753                 .accept(MediaType.APPLICATION_JSON)
 754                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 755                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 756                 .delete();
 757
 758         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_CONFLICT);
 759     }
 760
 761     @Test
 762     public void deleteArtifactOnResourceExceptionDuringDeleteTest() {
 763         String uuid = "uuidToThrow_deleteArtifactOnResource";
 764         String resourceInstanceName = "resourceInstanceNameToThrow_deleteArtifactOnResource";
 765         String artifactUUID = "artifactUUIDToThrow_deleteArtifactOnResource";
 766         Map<String,String> parametersMap = new HashMap<>();
 767         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 768         parametersMap.put(UUID, uuid);
 769         parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName);
 770         parametersMap.put(ARTIFACT_UUID, artifactUUID);
 771
 772         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 773         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 774
 775         given(artifactsBusinessLogic.deleteArtifactOnRiByUUID(any(), any(), eq(uuid),
 776                 eq(resourceInstanceName), eq(artifactUUID), any()))
 777                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 778
 779         Response response = target()
 780                 .path(path)
 781                 .request()
 782                 .accept(MediaType.APPLICATION_JSON)
 783                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 784                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 785                 .delete();
 786
 787         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 788     }
 789
 790     @Test
 791     public void deleteArtifactOnResourceTest() {
 792         Map<String,String> parametersMap = new HashMap<>();
 793         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 794         parametersMap.put(UUID, "uuid");
 795         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 796         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 797
 798         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 799         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 800
 801         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 802         Either<ArtifactDefinition, ResponseFormat> deleteArtifactOnRiByUUIDEither = Either.left(artifactDefinition);
 803
 804         given(artifactsBusinessLogic.deleteArtifactOnRiByUUID(any(), any(), any(), any(),
 805                 any(), any()))
 806                 .willAnswer( invocation -> deleteArtifactOnRiByUUIDEither);
 807
 808         Response response = target()
 809                 .path(path)
 810                 .request()
 811                 .accept(MediaType.APPLICATION_JSON)
 812                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 813                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 814                 .delete();
 815
 816         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 817     }
 818
 819     @Test
 820     public void downloadComponentArtifactErrorDuringDownloadProcessingTest() {
 821         Map<String,String> parametersMap = new HashMap<>();
 822         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 823         parametersMap.put(UUID, "uuid");
 824         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 825
 826         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 827         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 828
 829         Either<byte[], ResponseFormat> downloadComponentArtifactByUUIDsEither =
 830                 Either.right(new ResponseFormat(HttpStatus.SC_SERVICE_UNAVAILABLE));
 831
 832         given(artifactsBusinessLogic.downloadComponentArtifactByUUIDs(any(), any(), any(), any()))
 833                 .willAnswer( invocation -> downloadComponentArtifactByUUIDsEither);
 834
 835         Response response = target()
 836                 .path(path)
 837                 .request()
 838                 .accept(MediaType.APPLICATION_OCTET_STREAM)
 839                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 840                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 841                 .get();
 842
 843         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_SERVICE_UNAVAILABLE);
 844     }
 845
 846     @Test
 847     public void downloadComponentArtifactExceptionDuringUploadTest() {
 848         String uuid = "uuidToThrow_downloadComponentArtifact";
 849         String artifactUUID = "artifactUUIDToThrow_downloadComponentArtifact";
 850         Map<String,String> parametersMap = new HashMap<>();
 851         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 852         parametersMap.put(UUID, uuid);
 853         parametersMap.put(ARTIFACT_UUID, artifactUUID);
 854
 855         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 856         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 857
 858         given(artifactsBusinessLogic.downloadComponentArtifactByUUIDs(any(), eq(uuid),
 859                 eq(artifactUUID), any()))
 860                 .willAnswer( invocation -> { throw new IOException("Test exception"); });
 861
 862         Response response = target()
 863                 .path(path)
 864                 .request()
 865                 .accept(MediaType.APPLICATION_OCTET_STREAM)
 866                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 867                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 868                 .get();
 869
 870         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 871     }
 872
 873     @Test
 874     public void downloadComponentArtifactTest() {
 875         Map<String,String> parametersMap = new HashMap<>();
 876         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 877         parametersMap.put(UUID, "uuid");
 878         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 879
 880         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/artifacts/{artifactUUID}";
 881         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 882
 883         byte[] responsePayload = {0xA, 0xB, 0xC, 0xD};
 884         Either<byte[], ResponseFormat> downloadComponentArtifactByUUIDsEither = Either.left(responsePayload);
 885
 886         given(artifactsBusinessLogic.downloadComponentArtifactByUUIDs(any(), any(), any(), any()))
 887                 .willAnswer( invocation -> downloadComponentArtifactByUUIDsEither);
 888
 889         Response response = target()
 890                 .path(path)
 891                 .request()
 892                 .accept(MediaType.APPLICATION_OCTET_STREAM)
 893                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 894                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 895                 .get();
 896
 897         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 898     }
 899
 900     @Test
 901     public void downloadResourceInstanceArtifactErrorDuringDownloadProcessingTest() {
 902         Map<String,String> parametersMap = new HashMap<>();
 903         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 904         parametersMap.put(UUID, "uuid");
 905         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 906         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 907
 908         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 909         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 910
 911         Either<byte[], ResponseFormat> downloadResourceInstanceArtifactByUUIDsEither =
 912                 Either.right(new ResponseFormat(HttpStatus.SC_SERVICE_UNAVAILABLE));
 913
 914         given(artifactsBusinessLogic.downloadResourceInstanceArtifactByUUIDs(any(), any(), any(),
 915                 any()))
 916                 .willAnswer( invocation -> downloadResourceInstanceArtifactByUUIDsEither);
 917
 918         Response response = target()
 919                 .path(path)
 920                 .request()
 921                 .accept(MediaType.APPLICATION_OCTET_STREAM)
 922                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 923                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 924                 .get();
 925
 926         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_SERVICE_UNAVAILABLE);
 927     }
 928
 929     @Test
 930     public void downloadResourceInstanceArtifactExceptionDuringUploadTest() {
 931         String uuid = "uuidToThrow_downloadResourceInstanceArtifact";
 932         String resourceInstanceName = "resourceInstanceNameToThrow_downloadResourceInstanceArtifact";
 933         String artifactUUID = "artifactUUIDToThrow_downloadResourceInstanceArtifact";
 934         Map<String,String> parametersMap = new HashMap<>();
 935         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 936         parametersMap.put(UUID, uuid);
 937         parametersMap.put(RESOURCE_INSTANCE_NAME, resourceInstanceName);
 938         parametersMap.put(ARTIFACT_UUID, artifactUUID);
 939
 940         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 941         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 942
 943         when(artifactsBusinessLogic.downloadResourceInstanceArtifactByUUIDs(any(), eq(uuid),
 944                 eq(resourceInstanceName), eq(artifactUUID)))
 945                 .thenThrow(new ByResponseFormatComponentException(generalErrorResponseFormat));
 946
 947         Response response = target()
 948                 .path(path)
 949                 .request()
 950                 .accept(MediaType.APPLICATION_OCTET_STREAM)
 951                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 952                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 953                 .get();
 954
 955         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR);
 956     }
 957
 958     @Test
 959     public void downloadResourceInstanceArtifactTest() {
 960         Map<String,String> parametersMap = new HashMap<>();
 961         parametersMap.put(ASSET_TYPE, ComponentTypeEnum.SERVICE_PARAM_NAME);
 962         parametersMap.put(UUID, "uuid");
 963         parametersMap.put(RESOURCE_INSTANCE_NAME, "resourceInstanceName");
 964         parametersMap.put(ARTIFACT_UUID, "artifactUUID");
 965
 966         String formatEndpoint = "/v1/catalog/{assetType}/{uuid}/resourceInstances/{resourceInstanceName}/artifacts/{artifactUUID}";
 967         String path = StrSubstitutor.replace(formatEndpoint, parametersMap, "{","}");
 968
 969         byte[] responsePayload = {0xA, 0xB, 0xC, 0xD};
 970         Either<byte[], ResponseFormat> downloadResourceInstanceArtifactByUUIDsEither = Either.left(responsePayload);
 971
 972         given(artifactsBusinessLogic.downloadResourceInstanceArtifactByUUIDs(any(), any(), any(),
 973                 any()))
 974                 .willAnswer( invocation -> downloadResourceInstanceArtifactByUUIDsEither);
 975
 976         Response response = target()
 977                 .path(path)
 978                 .request()
 979                 .accept(MediaType.APPLICATION_OCTET_STREAM)
 980                 .header(Constants.X_ECOMP_INSTANCE_ID_HEADER, "mockXEcompInstanceId")
 981                 .header(Constants.USER_ID_HEADER, designerUser.getUserId())
 982                 .get();
 983
 984         assertThat(response.getStatus()).isEqualTo(HttpStatus.SC_OK);
 985     }
 986
 987     @Override
 988     protected Application configure() {
 989         ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 990         return new ResourceConfig(ArtifactExternalServlet.class)
 991                 .register(new AbstractBinder() {
 992
 993                     @Override
 994                     protected void configure() {
 995                         bind(request).to(HttpServletRequest.class);
 996                         bind(userBusinessLogic).to(UserBusinessLogic.class);
 997                         bind(componentInstanceBusinessLogic).to(ComponentInstanceBusinessLogic.class);
 998                         bind(componentUtils).to(ComponentsUtils.class);
 999                         bind(servletUtils).to(ServletUtils.class);
1000                         bind(resourceImportManager).to(ResourceImportManager.class);
1001                         bind(artifactsBusinessLogic).to(ArtifactsBusinessLogic.class);
1002                     }
1003                 })
1004                 .property("contextConfig", context);
1005     }
1006 }