catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.components.impl;
  24
  25 import static org.assertj.core.api.Assertions.assertThat;
  26 import static org.assertj.core.api.Assertions.assertThatCode;
  27 import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
  28 import static org.junit.Assert.assertArrayEquals;
  29 import static org.junit.Assert.assertEquals;
  30 import static org.junit.Assert.assertNotEquals;
  31 import static org.junit.Assert.assertNotNull;
  32 import static org.junit.Assert.assertNull;
  33 import static org.junit.Assert.assertTrue;
  34 import static org.junit.Assert.fail;
  35 import static org.mockito.ArgumentMatchers.any;
  36 import static org.mockito.ArgumentMatchers.anyBoolean;
  37 import static org.mockito.ArgumentMatchers.anyList;
  38 import static org.mockito.ArgumentMatchers.anyString;
  39 import static org.mockito.ArgumentMatchers.eq;
  40 import static org.mockito.Mockito.doReturn;
  41 import static org.mockito.Mockito.times;
  42 import static org.mockito.Mockito.verify;
  43 import static org.mockito.Mockito.when;
  44 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
  45 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
  46
  47 import com.fasterxml.jackson.annotation.JsonInclude;
  48 import com.fasterxml.jackson.databind.DeserializationFeature;
  49 import com.fasterxml.jackson.databind.ObjectMapper;
  50 import com.fasterxml.jackson.databind.SerializationFeature;
  51 import com.google.gson.Gson;
  52 import com.google.gson.GsonBuilder;
  53 import com.google.gson.JsonElement;
  54 import fj.data.Either;
  55 import java.io.IOException;
  56 import java.util.ArrayList;
  57 import java.util.Arrays;
  58 import java.util.Collections;
  59 import java.util.HashMap;
  60 import java.util.List;
  61 import java.util.Map;
  62 import java.util.Optional;
  63 import java.util.stream.Collectors;
  64 import mockit.Deencapsulation;
  65 import org.apache.commons.codec.binary.Base64;
  66 import org.apache.commons.collections.CollectionUtils;
  67 import org.apache.commons.collections.MapUtils;
  68 import org.apache.commons.lang3.tuple.ImmutablePair;
  69 import org.junit.Assert;
  70 import org.junit.Before;
  71 import org.junit.Test;
  72 import org.junit.runner.RunWith;
  73 import org.mockito.InjectMocks;
  74 import org.mockito.Mock;
  75 import org.mockito.Mockito;
  76 import org.mockito.MockitoAnnotations;
  77 import org.mockito.junit.MockitoJUnitRunner;
  78 import org.openecomp.sdc.be.MockGenerator;
  79 import org.openecomp.sdc.be.components.ArtifactsResolver;
  80 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  81 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
  82 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  83 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  84 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  85 import org.openecomp.sdc.be.components.utils.ArtifactBuilder;
  86 import org.openecomp.sdc.be.components.utils.ObjectGenerator;
  87 import org.openecomp.sdc.be.components.validation.UserValidations;
  88 import org.openecomp.sdc.be.config.ArtifactConfigManager;
  89 import org.openecomp.sdc.be.config.ArtifactConfiguration;
  90 import org.openecomp.sdc.be.config.ComponentType;
  91 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
  92 import org.openecomp.sdc.be.config.ConfigurationManager;
  93 import org.openecomp.sdc.be.dao.api.ActionStatus;
  94 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  95 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  96 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  97 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  98 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  99 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
 100 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
 101 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
 102 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 103 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 104 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 105 import org.openecomp.sdc.be.impl.ComponentsUtils;
 106 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
 107 import org.openecomp.sdc.be.model.ArtifactDefinition;
 108 import org.openecomp.sdc.be.model.ArtifactType;
 109 import org.openecomp.sdc.be.model.Component;
 110 import org.openecomp.sdc.be.model.ComponentInstance;
 111 import org.openecomp.sdc.be.model.ComponentParametersView;
 112 import org.openecomp.sdc.be.model.DataTypeDefinition;
 113 import org.openecomp.sdc.be.model.GroupDefinition;
 114 import org.openecomp.sdc.be.model.GroupInstance;
 115 import org.openecomp.sdc.be.model.HeatParameterDefinition;
 116 import org.openecomp.sdc.be.model.InterfaceDefinition;
 117 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 118 import org.openecomp.sdc.be.model.Operation;
 119 import org.openecomp.sdc.be.model.Resource;
 120 import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
 121 import org.openecomp.sdc.be.model.Service;
 122 import org.openecomp.sdc.be.model.User;
 123 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 124 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
 125 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
 126 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
 127 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
 128 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
 129 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 130 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
 131 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
 132 import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
 133 import org.openecomp.sdc.be.resources.data.DAOArtifactData;
 134 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 135 import org.openecomp.sdc.be.servlets.RepresentationUtils;
 136 import org.openecomp.sdc.be.tosca.CsarUtils;
 137 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
 138 import org.openecomp.sdc.be.user.Role;
 139 import org.openecomp.sdc.be.user.UserBusinessLogic;
 140 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 141 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
 142 import org.openecomp.sdc.common.datastructure.Wrapper;
 143 import org.openecomp.sdc.common.util.GeneralUtility;
 144 import org.openecomp.sdc.exception.ResponseFormat;
 145
 146 @RunWith(MockitoJUnitRunner.Silent.class)
 147 public class ArtifactsBusinessLogicTest extends BaseBusinessLogicMock {
 148
 149     public static final Resource resource = Mockito.mock(Resource.class);
 150     private static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN",
 151         System.currentTimeMillis());
 152     private static final String RESOURCE_INSTANCE_NAME = "Service-111";
 153     private static final String INSTANCE_ID = "S-123-444-ghghghg";
 154     private static final String ARTIFACT_NAME = "service-Myservice-template.yml";
 155     private static final String ARTIFACT_LABEL = "assettoscatemplate";
 156     private static final String ES_ARTIFACT_ID = "123123dfgdfgd0";
 157     private static final byte[] PAYLOAD = "some payload".getBytes();
 158     private static final String RESOURCE_NAME = "My-Resource_Name with   space";
 159     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 160     private static final String RESOURCE_SUBCATEGORY = "Router";
 161     private static final String ARTIFACT_PLACEHOLDER_FILE_EXTENSION = "fileExtension";
 162     private static User user = null;
 163     private static Resource resourceResponse = null;
 164     final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 165     @Mock
 166     public ComponentsUtils componentsUtils;
 167     @Mock
 168     public ToscaOperationFacade toscaOperationFacade;
 169     JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
 170     @Mock
 171     JanusGraphDao janusGraphDao;
 172     @InjectMocks
 173     private ArtifactsBusinessLogic artifactBL;
 174     @Mock
 175     private UserBusinessLogic userBusinessLogic;
 176     @Mock
 177     private ArtifactOperation artifactOperation;
 178     @Mock
 179     private IInterfaceLifecycleOperation lifecycleOperation;
 180     @Mock
 181     private UserAdminOperation userOperation;
 182     @Mock
 183     private IElementOperation elementOperation;
 184     @Mock
 185     private ArtifactCassandraDao artifactCassandraDao;
 186     @Mock
 187     private NodeTemplateOperation nodeTemplateOperation;
 188     @Mock
 189     private IGraphLockOperation graphLockOperation;
 190     @Mock
 191     private UserValidations userValidations;
 192     @Mock
 193     private ArtifactsResolver artifactsResolver;
 194     @Mock
 195     private CsarUtils csarUtils;
 196     @Mock
 197     private ToscaExportHandler toscaExportHandler;
 198     @Mock
 199     private LifecycleBusinessLogic lifecycleBusinessLogic;
 200     @Mock
 201     private ArtifactTypeOperation artifactTypeOperation;
 202
 203     private Gson gson = new GsonBuilder().setPrettyPrinting().create();
 204
 205     private static List<ArtifactType> getAllTypes() {
 206         final List<ArtifactConfiguration> artifactConfigurationList = ConfigurationManager.getConfigurationManager()
 207             .getConfiguration().getArtifacts();
 208         return artifactConfigurationList.stream().map(artifactConfiguration -> {
 209             final ArtifactType artifactType = new ArtifactType();
 210             artifactType.setName(artifactConfiguration.getType());
 211             return artifactType;
 212         }).collect(Collectors.toList());
 213     }
 214
 215     @Before
 216     public void initMocks() {
 217         MockitoAnnotations.openMocks(this);
 218         Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
 219             .right(StorageOperationStatus.NOT_FOUND);
 220
 221         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either
 222             .right(StorageOperationStatus.NOT_FOUND);
 223         when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Service), Mockito.anyBoolean()))
 224             .thenReturn(NotFoundResult2);
 225         when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Resource), Mockito.anyBoolean()))
 226             .thenReturn(NotFoundResult2);
 227
 228         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
 229             .right(StorageOperationStatus.NOT_FOUND);
 230         when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
 231             .thenReturn(notFoundInterfaces);
 232
 233         when(userOperation.getUserData("jh0003", false)).thenReturn(Either.left(USER));
 234
 235         when(elementOperation.getAllArtifactTypes()).thenReturn(getAllTypes());
 236
 237         when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
 238
 239         // User data and management
 240         user = new User();
 241         user.setUserId("jh0003");
 242         user.setFirstName("Jimmi");
 243         user.setLastName("Hendrix");
 244         user.setRole(Role.ADMIN.name());
 245
 246         // createResource
 247         resourceResponse = createResourceObject(true);
 248         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 249         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 250         when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(StorageOperationStatus.OK);
 251         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
 252         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(emptyDataTypes));
 253         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 254
 255         Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
 256             .right(StorageOperationStatus.BAD_REQUEST);
 257         when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
 258             .thenReturn(resourceStorageOperationStatusEither);
 259     }
 260
 261     @Test
 262     public void testValidJson() {
 263         ArtifactDefinition ad = createArtifactDef();
 264
 265         String jsonArtifact = "";
 266
 267         ObjectMapper mapper = new ObjectMapper();
 268         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 269         mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 270         mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 271
 272         try {
 273             jsonArtifact = mapper.writeValueAsString(ad);
 274         } catch (IOException e) {
 275             // TODO Auto-generated catch block
 276             e.printStackTrace();
 277         }
 278
 279         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
 280             ArtifactDefinition.class, false);
 281         assertEquals(ad, afterConvert);
 282     }
 283
 284     private ArtifactDefinition createArtifactDef() {
 285         ArtifactDefinition ad = new ArtifactDefinition();
 286         ad.setArtifactName("artifact1.yaml");
 287         ad.setArtifactLabel("label1");
 288         ad.setDescription("description");
 289         ad.setArtifactType(ArtifactTypeEnum.HEAT.getType());
 290         ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 291         ad.setCreationDate(System.currentTimeMillis());
 292         ad.setMandatory(false);
 293         ad.setTimeout(15);
 294         return ad;
 295     }
 296
 297     private Resource createResourceObject(boolean afterCreate) {
 298         Resource resource = new Resource();
 299         resource.setName(RESOURCE_NAME);
 300         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 301         resource.setDescription("My short description");
 302         List<String> tgs = new ArrayList<String>();
 303         tgs.add("test");
 304         tgs.add(resource.getName());
 305         resource.setTags(tgs);
 306         List<String> template = new ArrayList<String>();
 307         template.add("Root");
 308         resource.setDerivedFrom(template);
 309         resource.setVendorName("Motorola");
 310         resource.setVendorRelease("1.0.0");
 311         resource.setContactId("ya5467");
 312         resource.setIcon("MyIcon");
 313
 314         if (afterCreate) {
 315             resource.setName(resource.getName());
 316             resource.setVersion("0.1");
 317             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 318             resource.setCreatorUserId(user.getUserId());
 319             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 320             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 321         }
 322         return resource;
 323     }
 324
 325     @Test
 326     public void testUpdateCIDeploymentArtifactTimeout() {
 327         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 328         ArtifactDefinition envArtifact = new ArtifactDefinition();
 329         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 330         ComponentInstance ci = new ComponentInstance();
 331         ci.setUniqueId("ciid");
 332         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
 333         GroupInstance groupInstance = new GroupInstance();
 334         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 335         groupInstance.setCustomizationUUID("custUid");
 336         groupInstance.setUniqueId("guid");
 337         List<GroupInstance> groupInstances = new ArrayList<>();
 338         groupInstances.addAll(Arrays.asList(groupInstance));
 339         ci.setGroupInstances(groupInstances);
 340         Service service = new Service();
 341         service.setComponentInstances(Collections.singletonList(ci));
 342         service.setUniqueId("suid");
 343
 344         when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
 345             heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
 346             Either.left(heatArtifact));
 347         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 348             .thenReturn(StorageOperationStatus.OK);
 349         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
 350             .thenReturn(Either.left(new ArrayList()));
 351         when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
 352             new ArrayList<>(Arrays.asList("guid"))))
 353             .thenReturn(StorageOperationStatus.OK);
 354         artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
 355             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 356             "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 357         assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(envArtifact.getTimeout());
 358         assertThat(ci.getDeploymentArtifacts().get("HEAT_ENV").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
 359     }
 360
 361     @Test
 362     public void testUpdateCIDeploymentTimeout_invalidTimeout() {
 363         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 364         ArtifactDefinition envArtifact = new ArtifactDefinition();
 365         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 366         ComponentInstance ci = new ComponentInstance();
 367         ci.setUniqueId("ciid");
 368         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
 369         GroupInstance groupInstance = new GroupInstance();
 370         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 371         groupInstance.setCustomizationUUID("custUid");
 372         groupInstance.setUniqueId("guid");
 373         List<GroupInstance> groupInstances = new ArrayList<>();
 374         groupInstances.addAll(Arrays.asList(groupInstance));
 375         ci.setGroupInstances(groupInstances);
 376         Service service = new Service();
 377         service.setComponentInstances(Collections.singletonList(ci));
 378         service.setUniqueId("suid");
 379         envArtifact.setTimeout(130);
 380
 381         when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
 382             heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
 383             Either.left(heatArtifact));
 384         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 385             .thenReturn(StorageOperationStatus.OK);
 386         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
 387             .thenReturn(Either.left(new ArrayList()));
 388         when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
 389             new ArrayList<>(Arrays.asList("guid"))))
 390             .thenReturn(StorageOperationStatus.OK);
 391         try {
 392             artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
 393                 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 394                 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 395         } catch (ComponentException exp) {
 396             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
 397             return;
 398         }
 399         fail();
 400     }
 401
 402     @Test
 403     public void testUpdateCIDeploymentTimeout_negativeTimeout() {
 404         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 405         ArtifactDefinition envArtifact = new ArtifactDefinition();
 406         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 407         ComponentInstance ci = new ComponentInstance();
 408         ci.setUniqueId("ciid");
 409         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
 410         GroupInstance groupInstance = new GroupInstance();
 411         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 412         groupInstance.setCustomizationUUID("custUid");
 413         groupInstance.setUniqueId("guid");
 414         List<GroupInstance> groupInstances = new ArrayList<>();
 415         groupInstances.addAll(Arrays.asList(groupInstance));
 416         ci.setGroupInstances(groupInstances);
 417         Service service = new Service();
 418         service.setComponentInstances(Collections.singletonList(ci));
 419         service.setUniqueId("suid");
 420         envArtifact.setTimeout(-1);
 421
 422         when(artifactToscaOperation.updateArtifactOnResource(heatArtifact, service,
 423             heatArtifact.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE.getNodeType(), ci.getUniqueId(), false)).thenReturn(
 424             Either.left(heatArtifact));
 425         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 426             .thenReturn(StorageOperationStatus.OK);
 427         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
 428             .thenReturn(Either.left(new ArrayList()));
 429         when(toscaOperationFacade.generateCustomizationUUIDOnInstanceGroup(service.getUniqueId(), ci.getUniqueId(),
 430             new ArrayList<>(Arrays.asList("guid"))))
 431             .thenReturn(StorageOperationStatus.OK);
 432         try {
 433             artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
 434                 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 435                 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 436         } catch (ComponentException exp) {
 437             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_INVALID_TIMEOUT);
 438             return;
 439         }
 440         fail();
 441     }
 442
 443     @Test
 444     public void testUpdateCIDeploymentArtifactTimeout_noUpdate() {
 445         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 446         ArtifactDefinition envArtifact = new ArtifactDefinition();
 447         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 448         ComponentInstance ci = new ComponentInstance();
 449         ci.setUniqueId("ciid");
 450         ci.setDeploymentArtifacts(fillDeploymentArtifacts(heatArtifact, envArtifact, origEnvArtifact));
 451         envArtifact.setTimeout(heatArtifact.getTimeout());
 452         GroupInstance groupInstance = new GroupInstance();
 453         groupInstance.setGroupInstanceArtifacts(new ArrayList<>(Arrays.asList(heatArtifact.getUniqueId(), envArtifact.getUniqueId())));
 454         groupInstance.setCustomizationUUID("custUid");
 455         groupInstance.setUniqueId("guid");
 456         List<GroupInstance> groupInstances = new ArrayList<>();
 457         groupInstances.addAll(Arrays.asList(groupInstance));
 458         ci.setGroupInstances(groupInstances);
 459         Service service = new Service();
 460         service.setComponentInstances(Collections.singletonList(ci));
 461         service.setUniqueId("suid");
 462
 463         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 464             .thenReturn(StorageOperationStatus.OK);
 465         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
 466             .thenReturn(Either.left(new ArrayList()));
 467         artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
 468             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 469             "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 470         assertThat(ci.getDeploymentArtifacts().get("HEAT").getTimeout()).isEqualTo(origEnvArtifact.getTimeout());
 471     }
 472
 473     @Test
 474     public void testUpdateCIDeploymentArtifactTimeout_nonExistingArtifact() {
 475         ArtifactDefinition heatArtifact = new ArtifactDefinition();
 476         ArtifactDefinition envArtifact = new ArtifactDefinition();
 477         ArtifactDefinition origEnvArtifact = new ArtifactDefinition();
 478         envArtifact.setTimeout(heatArtifact.getTimeout());
 479         envArtifact.setArtifactType("HEAT_ENV");
 480         envArtifact.setGeneratedFromId("uid1");
 481         ComponentInstance ci = new ComponentInstance();
 482         ci.setUniqueId("ciid");
 483         ci.setDeploymentArtifacts(new HashMap<>());
 484         Service service = new Service();
 485         service.setComponentInstances(Collections.singletonList(ci));
 486         service.setUniqueId("suid");
 487
 488         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(service.getUniqueId(), ci.getUniqueId()))
 489             .thenReturn(StorageOperationStatus.OK);
 490         when(toscaOperationFacade.updateGroupInstancesOnComponent(eq(service), eq(ci.getUniqueId()), any(List.class)))
 491             .thenReturn(Either.left(new ArrayList()));
 492         assertThatThrownBy(() -> {
 493             artifactBL.handleUpdate(ci.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE,
 494                 new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 495                 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, service, true);
 496         }).isInstanceOf(ComponentException.class);
 497     }
 498
 499     @Test
 500     public void testUpdateCIDeploymentArtifactTimeout_invalidArtifactType() {
 501         ArtifactDefinition envArtifact = new ArtifactDefinition();
 502         envArtifact.setArtifactType("invalid");
 503
 504         try {
 505             artifactBL.handleUpdate("uid", ComponentTypeEnum.RESOURCE_INSTANCE, new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE),
 506                 "uid2", envArtifact, null, null, null, null, null, AuditingActionEnum.ARTIFACT_METADATA_UPDATE, user, null, true);
 507             fail();
 508         } catch (ComponentException exp) {
 509             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.ARTIFACT_TYPE_NOT_SUPPORTED);
 510             assertThat(exp.getParams()[0]).isEqualTo("invalid");
 511         }
 512     }
 513
 514     private Map<String, ArtifactDefinition> fillDeploymentArtifacts(ArtifactDefinition heatArtifact, ArtifactDefinition envArtifact,
 515                                                                     ArtifactDefinition origEnvArtifact) {
 516         heatArtifact.setArtifactType("HEAT");
 517         heatArtifact.setTimeout(60);
 518         heatArtifact.setEsId("es");
 519         heatArtifact.setArtifactUUID("uuid1");
 520         heatArtifact.setUniqueId("uid1");
 521         envArtifact.setArtifactUUID("uuid2");
 522         envArtifact.setArtifactType("HEAT_ENV");
 523         envArtifact.setTimeout(30);
 524         envArtifact.setGenerated(true);
 525         envArtifact.setGeneratedFromId("uid1");
 526         envArtifact.setUniqueId("uid2");
 527         origEnvArtifact.setUniqueId("uid2");
 528         origEnvArtifact.setGeneratedFromId("uid1");
 529         origEnvArtifact.setArtifactType("HEAT_ENV");
 530         origEnvArtifact.setTimeout(60);
 531         origEnvArtifact.setGenerated(true);
 532         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 533         deploymentArtifacts.put(heatArtifact.getArtifactType(), heatArtifact);
 534         //deploymentArtifacts.put(envArtifact.getArtifactType(), envArtifact);
 535         deploymentArtifacts.put(envArtifact.getArtifactType(), origEnvArtifact);
 536         return deploymentArtifacts;
 537     }
 538
 539     @Test
 540     public void testInvalidStringGroupType() {
 541         ArtifactDefinition ad = new ArtifactDefinition();
 542         ad.setArtifactName("artifact1");
 543         ad.setCreationDate(System.currentTimeMillis());
 544         ad.setMandatory(false);
 545         ad.setTimeout(15);
 546
 547         JsonElement jsonArtifact = gson.toJsonTree(ad);
 548         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
 549         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 550         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 551         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 552
 553         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 554             ArtifactDefinition.class, false);
 555         assertNull(afterConvert);
 556     }
 557
 558     @Test
 559     public void testUpdateArtifactWithEmptyBody() {
 560         try {
 561             RepresentationUtils.convertJsonToArtifactDefinition("", ArtifactDefinition.class, true);
 562             fail();
 563         } catch (ComponentException exp) {
 564             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_BODY);
 565         }
 566     }
 567
 568     @Test
 569     public void testInvalidNumberGroupType() {
 570         ArtifactDefinition ad = new ArtifactDefinition();
 571         ad.setArtifactName("artifact1");
 572         ad.setCreationDate(System.currentTimeMillis());
 573         ad.setMandatory(false);
 574         ad.setTimeout(15);
 575
 576         JsonElement jsonArtifact = gson.toJsonTree(ad);
 577         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
 578         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 579         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 580         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 581
 582         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 583             ArtifactDefinition.class, false);
 584         assertNull(afterConvert);
 585     }
 586
 587     @Test
 588     public void testMissingArtifactTypeValue() {
 589         ArtifactDefinition ad = new ArtifactDefinition();
 590
 591         JsonElement jsonArtifact = gson.toJsonTree(ad);
 592         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
 593         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 594         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 595         jsonArtifact.getAsJsonObject().add("artifactType", null);
 596         try {
 597             RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 598                 ArtifactDefinition.class, true);
 599             fail();
 600         } catch (ComponentException exp) {
 601             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MANDATORY_PROPERTY_MISSING_VALUE);
 602             assertThat(exp.getParams()[0]).isEqualTo("artifactType");
 603         }
 604     }
 605
 606     @Test
 607     public void testMissingArtifactLabel() {
 608         ArtifactDefinition ad = new ArtifactDefinition();
 609
 610         JsonElement jsonArtifact = gson.toJsonTree(ad);
 611         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
 612         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 613         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 614
 615         try {
 616             RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 617                 ArtifactDefinition.class, false);
 618             fail();
 619         } catch (ComponentException exp) {
 620             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
 621             assertThat(exp.getParams()[0]).isEqualTo("artifactLabel");
 622         }
 623     }
 624
 625     @Test
 626     public void testMissingArtifactTimeout() {
 627         ArtifactDefinition ad = new ArtifactDefinition();
 628
 629         JsonElement jsonArtifact = gson.toJsonTree(ad);
 630         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", ArtifactGroupTypeEnum.DEPLOYMENT.toString());
 631         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 632         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 633
 634         try {
 635             RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 636                 ArtifactDefinition.class, true);
 637             fail();
 638         } catch (ComponentException exp) {
 639             assertThat(exp.getActionStatus()).isEqualTo(ActionStatus.MISSING_MANDATORY_PROPERTY);
 640             assertThat(exp.getParams()[0]).isEqualTo("timeout");
 641         }
 642     }
 643
 644
 645     @Test
 646     public void testInvalidGroupTypeWithSpace() {
 647         ArtifactDefinition ad = new ArtifactDefinition();
 648         ad.setArtifactName("artifact1");
 649         ad.setCreationDate(System.currentTimeMillis());
 650         ad.setMandatory(false);
 651         ad.setTimeout(15);
 652
 653         JsonElement jsonArtifact = gson.toJsonTree(ad);
 654         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 655         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 656         jsonArtifact.getAsJsonObject().addProperty("timeout", " 80");
 657         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 658
 659         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 660             ArtifactDefinition.class, false);
 661         assertNull(afterConvert);
 662     }
 663
 664     @Test
 665     public void testInvalidTimeoutWithSpace() {
 666         ArtifactDefinition ad = new ArtifactDefinition();
 667         ad.setArtifactName("artifact1");
 668         ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 669         ad.setCreationDate(System.currentTimeMillis());
 670         ad.setMandatory(false);
 671
 672         JsonElement jsonArtifact = gson.toJsonTree(ad);
 673         jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
 674         jsonArtifact.getAsJsonObject().addProperty("artifactLabel", " label");
 675         jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 676         jsonArtifact.getAsJsonObject().addProperty("artifactType", " HEAT");
 677
 678         ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 679             ArtifactDefinition.class, true);
 680         assertNull(afterConvert);
 681     }
 682
 683     @Test
 684     public void testValidMibArtifactsConfiguration() {
 685         final ArtifactConfigManager artifactConfigManager = ArtifactConfigManager.getInstance();
 686         Optional<ArtifactConfiguration> artifactConfiguration = artifactConfigManager
 687             .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
 688         assertThat(artifactConfiguration.isPresent()).isTrue();
 689
 690         artifactConfiguration = artifactConfigManager
 691             .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE);
 692         assertThat(artifactConfiguration.isPresent()).isTrue();
 693
 694         artifactConfiguration = artifactConfigManager
 695             .find(ArtifactTypeEnum.SNMP_POLL.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
 696         assertThat(artifactConfiguration.isPresent()).isTrue();
 697         artifactConfiguration = artifactConfigManager
 698             .find(ArtifactTypeEnum.SNMP_TRAP.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, ComponentType.RESOURCE_INSTANCE);
 699         assertThat(artifactConfiguration.isPresent()).isTrue();
 700     }
 701
 702     @Test
 703     public void testDownloadServiceArtifactByNames() {
 704         Service service = new Service();
 705         String serviceName = "myService";
 706         String serviceVersion = "1.0";
 707         String serviceId = "serviceId";
 708         service.setName(serviceName);
 709         service.setVersion(serviceVersion);
 710         service.setUniqueId(serviceId);
 711
 712         String artifactName = "service-Myservice-template.yml";
 713         String artifactLabel = "assettoscatemplate";
 714         String esArtifactId = "123123dfgdfgd0";
 715         byte[] payload = "some payload".getBytes();
 716         ArtifactDefinition toscaTemplateArtifact = new ArtifactDefinition();
 717         toscaTemplateArtifact.setArtifactName(artifactName);
 718         toscaTemplateArtifact.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 719         toscaTemplateArtifact.setArtifactLabel(artifactLabel);
 720         toscaTemplateArtifact.setEsId(esArtifactId);
 721         toscaTemplateArtifact.setPayload(payload);
 722
 723         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 724         toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
 725         service.setToscaArtifacts(toscaArtifacts);
 726
 727         DAOArtifactData DAOArtifactData = new DAOArtifactData(esArtifactId);
 728         DAOArtifactData.setDataAsArray(payload);
 729         Either<DAOArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(DAOArtifactData);
 730         when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
 731         List<org.openecomp.sdc.be.model.Component> serviceList = new ArrayList<>();
 732         serviceList.add(service);
 733         Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> getServiceRes = Either
 734             .left(serviceList);
 735         when(toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName)).thenReturn(getServiceRes);
 736         byte[] downloadServiceArtifactByNamesRes = artifactBL
 737             .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
 738         assertThat(downloadServiceArtifactByNamesRes != null
 739             && downloadServiceArtifactByNamesRes.length == payload.length).isTrue();
 740     }
 741
 742     @Test
 743     public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
 744         ArtifactDefinition heatArtifact = new ArtifactBuilder()
 745             .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
 746             .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
 747
 748         Resource component = new Resource();
 749         component.setComponentType(ComponentTypeEnum.RESOURCE);
 750         when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
 751         when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 752             eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 753             .thenReturn(Either.left(new ArtifactDefinition()));
 754         ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 755             new ArrayList<>(), heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
 756             Collections.emptyMap());
 757         assertNull(heatEnvPlaceHolder.getListHeatParameters());
 758     }
 759
 760     @Test
 761     public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
 762         throws Exception {
 763         HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
 764         HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
 765         HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
 766         ArtifactDefinition heatArtifact = new ArtifactBuilder().addHeatParam(heatParam1).addHeatParam(heatParam2)
 767             .addHeatParam(heatParam3).build();
 768
 769         Resource component = new Resource();
 770
 771         when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(USER);
 772         when(artifactToscaOperation.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 773             eq(component), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 774             .thenReturn(Either.left(new ArtifactDefinition()));
 775
 776         ArtifactDefinition heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 777             new ArrayList<>(), heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
 778             Collections.emptyMap());
 779
 780         ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder;
 781         List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
 782         assertEquals(listHeatParameters.size(), 3);
 783         verifyHeatParam(listHeatParameters.get(0), heatParam1);
 784         verifyHeatParam(listHeatParameters.get(1), heatParam2);
 785         verifyHeatParam(listHeatParameters.get(2), heatParam3);
 786     }
 787
 788     @Test
 789     public void buildArtifactPayloadWhenShouldLockAndInTransaction() {
 790         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 791         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 792         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 793         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 794         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 795         artifactDefinition.setPayload(PAYLOAD);
 796         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 797
 798         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 799         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 800             any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
 801         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 802         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 803         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 804             ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
 805     }
 806
 807     @Test
 808     public void buildArtifactPayloadWhenShouldLockAndNotInTransaction() {
 809         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 810         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 811         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 812         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 813         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 814         artifactDefinition.setPayload(PAYLOAD);
 815         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 816
 817         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 818         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 819             any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
 820         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 821         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 822         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 823             ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 824         verify(janusGraphDao, times(1)).commit();
 825     }
 826
 827     private ArtifactDefinition buildArtifactPayload() {
 828         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 829         artifactDefinition.setArtifactName(ARTIFACT_NAME);
 830         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 831         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 832         artifactDefinition.setEsId(ES_ARTIFACT_ID);
 833         artifactDefinition.setPayload(PAYLOAD);
 834         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 835
 836         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 837         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 838             any(NodeTypeEnum.class), any(String.class), eq(true))).thenReturn(Either.left(artifactDefinition));
 839         when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 840         when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 841         artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 842             ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 843         verify(janusGraphDao, times(1)).commit();
 844         return artifactDefinition;
 845     }
 846
 847     private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
 848         assertEquals(heatEnvParam.getDefaultValue(), heatYamlParam.getCurrentValue());
 849         assertNull(heatEnvParam.getCurrentValue());
 850     }
 851
 852     //////////////////////////////////////////////////////////////////////////////////
 853     //////////////////////////////////new tests///////////////////////////////////////
 854     /////////////////////////////////////////////////////////////////////////////////
 855     private ArtifactsBusinessLogic createTestSubject() {
 856         return getTestSubject();
 857     }
 858
 859     @Test
 860     public void testCheckCreateFields() throws Exception {
 861         ArtifactsBusinessLogic testSubject;
 862         // User user = USER;
 863         ArtifactDefinition artifactInfo = buildArtifactPayload();
 864         ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
 865
 866         // default test
 867         testSubject = createTestSubject();
 868         Deencapsulation.invoke(testSubject, "checkCreateFields", user, artifactInfo, type);
 869     }
 870
 871     @Test
 872     public void testComposeArtifactId() throws Exception {
 873         ArtifactsBusinessLogic testSubject;
 874         String resourceId = "";
 875         String artifactId = "";
 876         ArtifactDefinition artifactInfo = buildArtifactPayload();
 877         String interfaceName = "";
 878         String operationName = "";
 879         String result;
 880
 881         // test 1
 882         testSubject = createTestSubject();
 883         result = Deencapsulation.invoke(testSubject, "composeArtifactId",
 884             new Object[]{resourceId, artifactId, artifactInfo, interfaceName, operationName});
 885     }
 886
 887     @Test
 888     public void testConvertParentType() throws Exception {
 889         ArtifactsBusinessLogic testSubject;
 890         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 891         NodeTypeEnum result;
 892
 893         // default test
 894         testSubject = createTestSubject();
 895         result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[]{componentType});
 896     }
 897
 898     @Test
 899     public void testConvertToOperation() throws Exception {
 900         ArtifactsBusinessLogic testSubject;
 901         ArtifactDefinition artifactInfo = buildArtifactPayload();
 902         String operationName = "";
 903         Operation result;
 904
 905         // default test
 906         testSubject = createTestSubject();
 907         result = Deencapsulation.invoke(testSubject, "convertToOperation",
 908             new Object[]{artifactInfo, operationName});
 909     }
 910
 911     @Test
 912     public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
 913         ArtifactsBusinessLogic testSubject;
 914         String operationName = "";
 915         String artifactName = "";
 916         String result;
 917
 918         // default test
 919         testSubject = createTestSubject();
 920         result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
 921             new Object[]{operationName, artifactName});
 922     }
 923
 924     @Test
 925     public void testFetchArtifactsFromComponent() throws Exception {
 926         ArtifactsBusinessLogic testSubject;
 927         String artifactId = "";
 928         Component component = createResourceObject(true);
 929         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 930
 931         // default test
 932         testSubject = createTestSubject();
 933         Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
 934             artifactId, component, artifacts);
 935     }
 936
 937     @Test
 938     public void testValidateArtifact() throws Exception {
 939         ArtifactsBusinessLogic testSubject;
 940         String componentId = "";
 941         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 942         ArtifactsBusinessLogic arb = getTestSubject();
 943         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 944         String artifactId = "";
 945         ArtifactDefinition artifactInfo = buildArtifactPayload();
 946         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
 947
 948         Component component = createResourceObject(true);
 949         boolean shouldLock = false;
 950         boolean inTransaction = false;
 951
 952         // default test
 953         testSubject = createTestSubject();
 954         testSubject.validateArtifact(componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, shouldLock,
 955             inTransaction);
 956     }
 957
 958     @Test
 959     public void testHandleHeatEnvDownload() throws Exception {
 960         ArtifactsBusinessLogic testSubject;
 961         String componentId = "";
 962         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 963
 964         Component component = createResourceObject(true);
 965         ArtifactDefinition artifactInfo = buildArtifactPayload();
 966         boolean shouldLock = false;
 967         boolean inTransaction = false;
 968
 969         // default test
 970         testSubject = createTestSubject();
 971         testSubject.handleHeatEnvDownload(componentId, componentType, user, component, artifactInfo, shouldLock, inTransaction);
 972     }
 973
 974     @Test
 975     public void testArtifactGenerationRequired() throws Exception {
 976         ArtifactsBusinessLogic testSubject;
 977         Component component = createResourceObject(true);
 978         ArtifactDefinition artifactInfo = buildArtifactPayload();
 979         boolean result;
 980
 981         // default test
 982         testSubject = createTestSubject();
 983         result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
 984             new Object[]{component, artifactInfo});
 985     }
 986
 987     @Test
 988     public void testUpdateGroupForHeat() throws Exception {
 989         ArtifactsBusinessLogic testSubject;
 990         ArtifactDefinition artifactInfo = buildArtifactPayload();
 991         ArtifactDefinition artAfterUpdate = null;
 992         Component component = createResourceObject(true);
 993         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 994
 995         // default test
 996         testSubject = createTestSubject();
 997         testSubject.updateGroupForHeat(artifactInfo, artifactInfo, component);
 998     }
 999
1000     @Test
1001     public void testUpdateGroupForHeat_1() throws Exception {
1002         ArtifactsBusinessLogic testSubject;
1003         ArtifactDefinition artifactInfo = buildArtifactPayload();
1004         Component component = createResourceObject(true);
1005         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1006
1007         // default test
1008         testSubject = createTestSubject();
1009         testSubject.updateGroupForHeat(artifactInfo, artifactInfo, artifactInfo,
1010             artifactInfo, component);
1011     }
1012
1013
1014     @Test
1015     public void testHandleAuditing() throws Exception {
1016         ArtifactsBusinessLogic testSubject;
1017         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1018         Component component = createResourceObject(true);
1019         String componentId = "";
1020
1021         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1022         String prevArtifactUuid = "";
1023         String currentArtifactUuid = "";
1024         ResponseFormat responseFormat = new ResponseFormat();
1025         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1026         String resourceInstanceName = "";
1027
1028         // test 1
1029         testSubject = createTestSubject();
1030         testSubject.setComponentsUtils(MockGenerator.mockComponentUtils());
1031         testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
1032             prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
1033     }
1034
1035     @Test
1036     public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
1037         ArtifactsBusinessLogic testSubject;
1038         ArtifactsBusinessLogic arb = getTestSubject();
1039         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1040         ArtifactDefinition artifactInfo = buildArtifactPayload();
1041         ArtifactDefinition currentArtifactInfo = null;
1042
1043         // default test
1044         testSubject = createTestSubject();
1045         Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
1046             operation, artifactInfo, artifactInfo);
1047     }
1048
1049     @Test
1050     public void testFindArtifactOnParentComponent() {
1051         ArtifactsBusinessLogic testSubject;
1052         Component component = createResourceObject(true);
1053         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1054         String parentId = "";
1055         ArtifactsBusinessLogic arb = getTestSubject();
1056         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1057         String artifactId = "";
1058         Either<ArtifactDefinition, ResponseFormat> result;
1059
1060         // default test
1061         testSubject = createTestSubject();
1062         result = Deencapsulation.invoke(testSubject, "findArtifact", new Object[]{component,
1063             componentType, parentId, operation, artifactId});
1064     }
1065
1066
1067     @Test
1068     public void testValidateInformationalArtifact() throws Exception {
1069         ArtifactsBusinessLogic testSubject;
1070         ArtifactDefinition artifactInfo = buildArtifactPayload();
1071         Component component = createResourceObject(true);
1072         Either<Boolean, ResponseFormat> result;
1073
1074         // default test
1075         testSubject = createTestSubject();
1076         result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
1077             new Object[]{artifactInfo, component});
1078     }
1079
1080
1081     @Test
1082     public void testGetUpdatedGroups() throws Exception {
1083         ArtifactsBusinessLogic testSubject;
1084         String artifactId = "";
1085         ArtifactDefinition artifactInfo = buildArtifactPayload();
1086         List<GroupDefinition> groups = new ArrayList<>();
1087         List<GroupDataDefinition> result;
1088
1089         // test 1
1090         testSubject = createTestSubject();
1091         result = Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
1092     }
1093
1094
1095     @Test
1096     public void testGetUpdatedGroupInstances() throws Exception {
1097         ArtifactsBusinessLogic testSubject;
1098         String artifactId = "";
1099         ArtifactDefinition artifactInfo = buildArtifactPayload();
1100         List<GroupDefinition> groups = new ArrayList<>();
1101         List<GroupInstance> result;
1102
1103         // default test
1104         testSubject = createTestSubject();
1105         result = Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
1106     }
1107
1108
1109     @Test
1110     public void testFindArtifact_1() throws Exception {
1111         ArtifactsBusinessLogic testSubject;
1112         String artifactId = "";
1113         Component component = createResourceObject(true);
1114         String parentId = "";
1115         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1116         Either<ImmutablePair<ArtifactDefinition, ComponentInstance>, ActionStatus> result;
1117
1118         // default test
1119         testSubject = createTestSubject();
1120         result = Deencapsulation.invoke(testSubject, "findArtifact",
1121             new Object[]{artifactId, component, parentId, componentType});
1122     }
1123
1124
1125     @Test
1126     public void testFetchArtifactsFromInstance() throws Exception {
1127         ArtifactsBusinessLogic testSubject;
1128         String artifactId = "";
1129         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1130         ComponentInstance instance = new ComponentInstance();
1131
1132         // default test
1133         testSubject = createTestSubject();
1134         Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
1135     }
1136
1137
1138     @Test
1139     public void testGenerateCustomizationUUIDOnInstance() throws Exception {
1140         ArtifactsBusinessLogic testSubject;
1141         String componentId = "";
1142         String instanceId = "";
1143         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1144         StorageOperationStatus result;
1145
1146         // default test
1147         testSubject = createTestSubject();
1148         result = Deencapsulation.invoke(testSubject, "generateCustomizationUUIDOnInstance",
1149             new Object[]{componentId, instanceId, componentType});
1150     }
1151
1152     @Test
1153     public void testFindComponentInstance() {
1154         ArtifactsBusinessLogic testSubject;
1155         String componentInstanceId = "";
1156         Component component = createResourceObject(true);
1157         ComponentInstance result;
1158
1159         // default test
1160         testSubject = createTestSubject();
1161         result = Deencapsulation.invoke(testSubject, "findComponentInstance",
1162             new Object[]{componentInstanceId, component});
1163     }
1164
1165     @Test(expected = ComponentException.class)
1166     public void testDeploymentArtifactTypeIsLegalForParent_shouldThrowException() {
1167         ArtifactsBusinessLogic testSubject;
1168         ArtifactDefinition artifactInfo = buildArtifactPayload();
1169         ArtifactTypeEnum artifactType = ArtifactTypeEnum.AAI_SERVICE_MODEL;
1170         Map<String, ArtifactTypeConfig> resourceDeploymentArtifacts = new HashMap<>();
1171         // test 1
1172         testSubject = createTestSubject();
1173         testSubject.validateDeploymentArtifactTypeIsLegalForParent(artifactInfo, artifactType, resourceDeploymentArtifacts);
1174     }
1175
1176     @Test
1177     public void testLoadArtifactTypeConfig() {
1178         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1179         //null artifactType
1180         Optional<ArtifactConfiguration> artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(null);
1181         assertThat(artifactConfiguration.isPresent()).isFalse();
1182         //not configured artifactType
1183         artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig("NotConfiguredArtifactType");
1184         assertThat(artifactConfiguration.isPresent()).isFalse();
1185
1186         //valid artifactType
1187         final String artifactType = ArtifactTypeEnum.YANG.getType();
1188         artifactConfiguration = artifactsBusinessLogic.loadArtifactTypeConfig(artifactType);
1189         assertThat(artifactConfiguration.isPresent()).isTrue();
1190         final ArtifactConfiguration artifactConfiguration1 = artifactConfiguration.get();
1191         assertThat(artifactConfiguration1.getType()).isEqualTo(artifactType);
1192         assertThat(artifactConfiguration1.getCategories()).hasSize(1);
1193         assertThat(artifactConfiguration1.getCategories()).contains(ArtifactGroupTypeEnum.INFORMATIONAL);
1194         assertThat(artifactConfiguration1.getComponentTypes()).hasSize(1);
1195         assertThat(artifactConfiguration1.getComponentTypes()).contains(ComponentType.RESOURCE);
1196         assertThat(artifactConfiguration1.getResourceTypes()).hasSize(11);
1197         assertThat(artifactConfiguration1.getResourceTypes())
1198             .contains(ResourceTypeEnum.VFC.getValue(), ResourceTypeEnum.CP.getValue(), ResourceTypeEnum.VL.getValue(),
1199                 ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.VFCMT.getValue(), "Abstract",
1200                 ResourceTypeEnum.CVFC.getValue());
1201     }
1202
1203     @Test
1204     public void testValidateArtifactExtension_acceptedExtension() {
1205         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1206         artifactInfo.setArtifactName("artifact.yml");
1207         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1208         //empty accepted types
1209         assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(new ArtifactConfiguration(), artifactInfo))
1210             .doesNotThrowAnyException();
1211
1212         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1213         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1214         assertThatCode(() -> artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo))
1215             .doesNotThrowAnyException();
1216     }
1217
1218     @Test(expected = ComponentException.class)
1219     public void testValidateArtifactExtension_notAcceptedExtension() {
1220         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1221         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1222         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1223         //not accepted extension
1224         artifactInfo.setArtifactName("artifact.xml");
1225
1226         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1227
1228         artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1229     }
1230
1231     @Test(expected = ComponentException.class)
1232     public void testValidateArtifactExtension_noExtension() {
1233         final ArtifactConfiguration artifactConfiguration = new ArtifactConfiguration();
1234         artifactConfiguration.setAcceptedTypes(Arrays.asList("yml", "yaml"));
1235         final ArtifactDefinition artifactInfo = new ArtifactDefinition();
1236         //no extension in the artifact name
1237         artifactInfo.setArtifactName("artifact");
1238
1239         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1240
1241         artifactsBusinessLogic.validateArtifactExtension(artifactConfiguration, artifactInfo);
1242     }
1243
1244     @Test(expected = ComponentException.class)
1245     public void testValidateHeatEnvDeploymentArtifact_shouldThrowException() {
1246         ArtifactsBusinessLogic testSubject;
1247         Component component = createResourceObject(true);
1248         String parentId = "";
1249         ArtifactDefinition artifactInfo = buildArtifactPayload();
1250         // default test
1251         testSubject = createTestSubject();
1252         testSubject.validateHeatEnvDeploymentArtifact(component, parentId, artifactInfo);
1253     }
1254
1255     @Test
1256     public void testFillArtifactPayloadValidation() throws Exception {
1257         ArtifactsBusinessLogic testSubject;
1258         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1259         Wrapper<byte[]> payloadWrapper = new Wrapper<>();
1260         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1261
1262         // default test
1263         testSubject = createTestSubject();
1264         testSubject.fillArtifactPayload(payloadWrapper, artifactDefinition);
1265     }
1266
1267     @Test(expected = ByActionStatusComponentException.class)
1268     public void testHeatTimeoutValue() {
1269         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1270         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1271         artifactInfo.setTimeout(1);
1272         artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1273         artifactInfo.setTimeout(0);
1274         artifactsBusinessLogic.validateHeatTimeoutValue(artifactInfo);
1275     }
1276
1277     @Test
1278     public void testValidateResourceType_resourceTypeIsAccepted() {
1279         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1280         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1281         final List<String> typeList = Arrays
1282             .asList(ResourceTypeEnum.VF.getValue(), ResourceTypeEnum.PNF.getValue(), ResourceTypeEnum.VFC.getValue());
1283         assertThatCode(() -> {
1284             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1285         }).doesNotThrowAnyException();
1286     }
1287
1288     @Test(expected = ComponentException.class)
1289     public void testValidateResourceType_invalidResourceType() {
1290         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1291         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1292         final List<String> typeList = Collections.singletonList(ResourceTypeEnum.PNF.getValue());
1293         artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, typeList);
1294     }
1295
1296     @Test
1297     public void testValidateResourceType_emptyResourceTypeConfig_resourceTypeIsAccepted() {
1298         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1299         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1300         assertThatCode(() -> {
1301             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, null);
1302         }).doesNotThrowAnyException();
1303         assertThatCode(() -> {
1304             artifactsBusinessLogic.validateResourceType(ResourceTypeEnum.VF, artifactInfo, new ArrayList<>());
1305         }).doesNotThrowAnyException();
1306     }
1307
1308     @Test
1309     public void testValidateAndConvertHeatParameters() throws Exception {
1310         ArtifactsBusinessLogic testSubject;
1311         ArtifactDefinition artifactInfo = buildArtifactPayload();
1312         String artifactType = "";
1313         Either<ArtifactDefinition, ResponseFormat> result;
1314
1315         // default test
1316         testSubject = createTestSubject();
1317         testSubject.validateAndConvertHeatParameters(artifactInfo, artifactType);
1318     }
1319
1320     @Test
1321     public void testGetDeploymentArtifacts() throws Exception {
1322         ArtifactsBusinessLogic testSubject;
1323         Component component = createResourceObject(true);
1324         NodeTypeEnum parentType = null;
1325         String ciId = "";
1326         List<ArtifactDefinition> result;
1327
1328         // default test
1329         testSubject = createTestSubject();
1330         result = testSubject.getDeploymentArtifacts(component, ciId);
1331     }
1332
1333
1334     @Test
1335     public void testValidateFirstUpdateHasPayload() throws Exception {
1336         ArtifactsBusinessLogic testSubject;
1337         ArtifactDefinition artifactInfo = buildArtifactPayload();
1338         ArtifactDefinition currentArtifact = null;
1339         Either<Boolean, ResponseFormat> result;
1340
1341         // default test
1342         testSubject = createTestSubject();
1343         result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1344             new Object[]{artifactInfo, artifactInfo});
1345     }
1346
1347     @Test
1348     public void testValidateAndSetArtifactname() throws Exception {
1349         ArtifactsBusinessLogic testSubject;
1350         ArtifactDefinition artifactInfo = buildArtifactPayload();
1351         Either<Boolean, ResponseFormat> result;
1352
1353         // default test
1354         testSubject = createTestSubject();
1355         testSubject.validateAndSetArtifactName(artifactInfo);
1356     }
1357
1358     @Test(expected = ComponentException.class)
1359     public void testValidateArtifactType_notConfiguredArtifactType() {
1360         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1361         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1362         artifactInfo.setArtifactType("notConfiguredType");
1363         Deencapsulation
1364             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1365     }
1366
1367     @Test(expected = ComponentException.class)
1368     public void testValidateArtifactType_componentTypeNotSupportedByArtifactType() {
1369         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1370         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1371         artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1372
1373         Deencapsulation
1374             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.RESOURCE);
1375     }
1376
1377     @Test(expected = ComponentException.class)
1378     public void testValidateArtifactType_groupTypeNotSupportedByArtifactType() {
1379         final ArtifactsBusinessLogic artifactsBusinessLogic = createTestSubject();
1380         final ArtifactDefinition artifactInfo = buildArtifactPayload();
1381         artifactInfo.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
1382         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1383
1384         Deencapsulation
1385             .invoke(artifactsBusinessLogic, "validateArtifactType", artifactInfo, ComponentTypeEnum.SERVICE);
1386     }
1387
1388     @Test
1389     public void testValidateArtifactTypeNotChanged() throws Exception {
1390         ArtifactsBusinessLogic testSubject;
1391         ArtifactDefinition artifactInfo = buildArtifactPayload();
1392         ArtifactDefinition currentArtifact = null;
1393         Either<Boolean, ResponseFormat> result;
1394
1395         // default test
1396         testSubject = createTestSubject();
1397         result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1398             new Object[]{artifactInfo, artifactInfo});
1399     }
1400
1401
1402     @Test
1403     public void testValidateOrSetArtifactGroupType() throws Exception {
1404         ArtifactsBusinessLogic testSubject;
1405         ArtifactDefinition artifactInfo = buildArtifactPayload();
1406         ArtifactDefinition currentArtifact = null;
1407         Either<ArtifactDefinition, ResponseFormat> result;
1408
1409         // default test
1410         testSubject = createTestSubject();
1411         result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1412             new Object[]{artifactInfo, artifactInfo});
1413     }
1414
1415     @Test
1416     public void testCheckAndSetUnUpdatableFields() throws Exception {
1417         ArtifactsBusinessLogic testSubject;
1418
1419         ArtifactDefinition artifactInfo = buildArtifactPayload();
1420         ArtifactDefinition currentArtifact = null;
1421         ArtifactGroupTypeEnum type = null;
1422
1423         // test 1
1424         testSubject = createTestSubject();
1425         type = null;
1426         Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", user,
1427             artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class);
1428     }
1429
1430     @Test
1431     public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1432         ArtifactsBusinessLogic testSubject;
1433         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1434         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1435
1436         // default test
1437         testSubject = createTestSubject();
1438         Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1439     }
1440
1441     @Test
1442     public void testGetMapOfParameters() throws Exception {
1443         ArtifactsBusinessLogic testSubject;
1444         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1445         Map<String, HeatParameterDefinition> result;
1446
1447         // default test
1448         testSubject = createTestSubject();
1449         result = Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1450     }
1451
1452     @Test
1453     public void testGivenValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1454         final byte[] payload = "validYaml: yes".getBytes();
1455         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1456
1457         final boolean isArtifactMetadataUpdate = false;
1458         ArtifactsBusinessLogic testSubject = getTestSubject();
1459
1460         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1461             new Object[]{artifactInfo, isArtifactMetadataUpdate});
1462         assertArrayEquals(payload, result.left().value());
1463     }
1464
1465
1466     @Test
1467     public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1468         final int expectedStatus = 100;
1469         when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1470         final byte[] payload = "invalidYaml".getBytes();
1471         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1472
1473         final boolean isArtifactMetadataUpdate = false;
1474         ArtifactsBusinessLogic testSubject = getTestSubject();
1475         testSubject.setComponentsUtils(componentsUtils);
1476
1477         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1478             new Object[]{artifactInfo, isArtifactMetadataUpdate});
1479
1480         int status = result.right().value().getStatus();
1481         assertEquals(expectedStatus, status);
1482     }
1483
1484     @Test
1485     public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
1486         final int expectedStatus = 101;
1487         when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1488         final byte[] payload = "".getBytes();
1489         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1490
1491         final boolean isArtifactMetadataUpdate = false;
1492         ArtifactsBusinessLogic testSubject = getTestSubject();
1493         testSubject.setComponentsUtils(componentsUtils);
1494
1495         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1496             new Object[]{artifactInfo, isArtifactMetadataUpdate});
1497
1498         int status = result.right().value().getStatus();
1499         assertEquals(expectedStatus, status);
1500     }
1501
1502
1503     @Test
1504     public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1505         final byte[] payload = "heat_template_version: 1.0".getBytes();
1506         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1507
1508         final boolean isArtifactMetadataUpdate = false;
1509         ArtifactsBusinessLogic testSubject = getTestSubject();
1510
1511         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1512             new Object[]{artifactInfo, isArtifactMetadataUpdate});
1513         assertArrayEquals(payload, result.left().value());
1514     }
1515
1516     @Test
1517     public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1518         final int expectedStatus = 1000;
1519         when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(
1520             new ResponseFormat(expectedStatus));
1521         final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
1522         ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1523
1524         final boolean isArtifactMetadataUpdate = false;
1525         ArtifactsBusinessLogic testSubject = getTestSubject();
1526         testSubject.setComponentsUtils(componentsUtils);
1527
1528         Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1529             new Object[]{artifactInfo, isArtifactMetadataUpdate});
1530
1531         int status = result.right().value().getStatus();
1532         assertEquals(expectedStatus, status);
1533     }
1534
1535     private ArtifactDefinition createArtifactInfo(byte[] payload, String artifactName, ArtifactTypeEnum artifactType) {
1536         ArtifactDefinition artifactInfo = new ArtifactDefinition();
1537         artifactInfo.setArtifactName(artifactName);
1538         artifactInfo.setArtifactType(artifactType.getType());
1539         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1540         artifactInfo.setPayload(Base64.encodeBase64(payload));
1541         return artifactInfo;
1542     }
1543
1544     @Test
1545     public void testValidateUserRole() throws Exception {
1546         ArtifactsBusinessLogic testSubject;
1547
1548         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
1549         String componentId = "";
1550         String artifactId = "";
1551         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1552         ArtifactsBusinessLogic arb = getTestSubject();
1553         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1554         Either<Boolean, ResponseFormat> result;
1555
1556         // default test
1557         testSubject = createTestSubject();
1558         result = Deencapsulation.invoke(testSubject, "validateUserRole",
1559             new Object[]{user, auditingAction, componentId, artifactId, componentType,
1560                 operation});
1561         assertNull(result);
1562     }
1563
1564     @Test
1565     public void testDetectAuditingType() throws Exception {
1566         ArtifactsBusinessLogic testSubject;
1567         ArtifactsBusinessLogic arb = getTestSubject();
1568         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1569         String origMd5 = "";
1570         AuditingActionEnum result;
1571
1572         // default test
1573         testSubject = createTestSubject();
1574         result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1575             new Object[]{operation, origMd5});
1576         assertNotNull(result);
1577     }
1578
1579     @Test
1580     public void testDetectNoAuditingType() throws Exception {
1581         ArtifactsBusinessLogic testSubject;
1582         ArtifactsBusinessLogic arb = getTestSubject();
1583         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.LINK);
1584         String origMd5 = "";
1585         AuditingActionEnum result;
1586
1587         // default test
1588         testSubject = createTestSubject();
1589         result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1590             new Object[]{operation, origMd5});
1591         assertNull(result);
1592     }
1593
1594     @Test
1595     public void testCreateEsArtifactData() throws Exception {
1596         ArtifactsBusinessLogic testSubject;
1597         ArtifactDataDefinition artifactInfo = buildArtifactPayload();
1598         byte[] artifactPayload = new byte[]{' '};
1599         DAOArtifactData result;
1600
1601         // default test
1602         testSubject = createTestSubject();
1603         result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1604         assertNotNull(result);
1605     }
1606
1607
1608     @Test
1609     public void testIsArtifactMetadataUpdateTrue() throws Exception {
1610         ArtifactsBusinessLogic testSubject;
1611         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ARTIFACT_METADATA_UPDATE;
1612         boolean result;
1613
1614         // default test
1615         testSubject = createTestSubject();
1616         result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1617             new Object[]{auditingActionEnum});
1618         assertThat(result).isTrue();
1619     }
1620
1621     @Test
1622     public void testIsArtifactMetadataUpdateFalse() throws Exception {
1623         ArtifactsBusinessLogic testSubject;
1624         AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1625         boolean result;
1626
1627         // default test
1628         testSubject = createTestSubject();
1629         result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1630             new Object[]{auditingActionEnum});
1631         assertThat(result).isFalse();
1632     }
1633
1634     @Test
1635     public void testIsDeploymentArtifactTrue() throws Exception {
1636         ArtifactsBusinessLogic testSubject;
1637         ArtifactDefinition artifactInfo = buildArtifactPayload();
1638         artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1639         boolean result;
1640
1641         // default test
1642         testSubject = createTestSubject();
1643         result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1644         assertThat(result).isTrue();
1645     }
1646
1647     @Test
1648     public void testIsDeploymentArtifactFalse() throws Exception {
1649         ArtifactsBusinessLogic testSubject;
1650         ArtifactDefinition artifactInfo = buildArtifactPayload(); // artifactGroupType == ArtifactGroupTypeEnum.TOSCA
1651         boolean result;
1652
1653         // default test
1654         testSubject = createTestSubject();
1655         result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[]{artifactInfo});
1656         assertThat(result).isFalse();
1657     }
1658
1659     @Test
1660     public void testSetArtifactPlaceholderCommonFields() throws Exception {
1661         ArtifactsBusinessLogic testSubject;
1662         String resourceId = ES_ARTIFACT_ID;
1663
1664         ArtifactDefinition artifactInfo = buildArtifactPayload();
1665
1666         // test 1
1667         testSubject = createTestSubject();
1668         Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1669             resourceId, user, artifactInfo);
1670         assertEquals(resourceId + "." + ARTIFACT_LABEL, artifactInfo.getUniqueId());
1671         assertEquals(user.getFullName(), artifactInfo.getCreatorFullName());
1672     }
1673
1674
1675     @Test
1676     public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1677         ArtifactsBusinessLogic testSubject;
1678         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1679         String payloadStr = "";
1680         Either<DAOArtifactData, ResponseFormat> result;
1681
1682         // default test
1683         testSubject = createTestSubject();
1684         result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1685             new Object[]{artifactDefinition, payloadStr});
1686         assertThat(result.isLeft()).isTrue();
1687     }
1688
1689     @Test
1690     public void testUpdateArtifactOnGroupInstance() throws Exception {
1691         ArtifactsBusinessLogic testSubject;
1692         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1693         Component component = createResourceObject(true);
1694         String instanceId = "";
1695         String prevUUID = "";
1696         ArtifactDefinition artifactInfo = buildArtifactPayload();
1697         Either<ArtifactDefinition, ResponseFormat> result;
1698
1699         // test 1
1700         testSubject = createTestSubject();
1701         result = testSubject.updateArtifactOnGroupInstance(component, instanceId, prevUUID, artifactInfo, artifactInfo);
1702         assertThat(result.isLeft()).isTrue();
1703     }
1704
1705     @Test
1706     public void testGenerateHeatEnvPayload() throws Exception {
1707         ArtifactsBusinessLogic testSubject;
1708         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1709         String result;
1710
1711         // default test
1712         testSubject = createTestSubject();
1713         result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1714             new Object[]{artifactDefinition});
1715         assertThat(result.isEmpty()).isFalse();
1716     }
1717
1718
1719     @Test
1720     public void testBuildJsonForUpdateArtifact() throws Exception {
1721         ArtifactsBusinessLogic testSubject;
1722         ArtifactDefinition artifactInfo = buildArtifactPayload();
1723         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1724         List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1725         Map<String, Object> result;
1726
1727         // default test
1728         testSubject = createTestSubject();
1729         result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1730         assertThat(MapUtils.isNotEmpty(result)).isTrue();
1731     }
1732
1733     @Test
1734     public void testBuildJsonForUpdateArtifact_1() throws Exception {
1735         ArtifactsBusinessLogic testSubject;
1736         String artifactId = "";
1737         String artifactName = "";
1738         String artifactType = "";
1739         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1740         String label = "";
1741         String displayName = "";
1742         String description = "";
1743         byte[] artifactContent = new byte[]{' '};
1744         List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1745         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1746         Map<String, Object> result;
1747
1748         // test 1
1749         testSubject = createTestSubject();
1750         artifactId = "";
1751         result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1752             label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1753         assertThat(MapUtils.isNotEmpty(result)).isTrue();
1754     }
1755
1756
1757     @Test
1758     public void testNotReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1759         ArtifactsBusinessLogic testSubject;
1760         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1761         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1762
1763         // default test
1764         testSubject = createTestSubject();
1765         boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue",
1766             new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1767         assertThat(result).isFalse();
1768     }
1769
1770
1771     @Test
1772     public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1773         ArtifactsBusinessLogic testSubject;
1774         HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1775         hpdOrig.setName("param1");
1776         hpdOrig.setCurrentValue("value1");
1777
1778         HeatParameterDefinition hpdUpd = new HeatParameterDefinition();
1779         hpdUpd.setName("param1");
1780         hpdUpd.setCurrentValue("value2");
1781
1782         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1783         currentHeatEnvParams.add(hpdOrig);
1784
1785         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1786         updatedHeatEnvParams.add(hpdUpd);
1787
1788         // default test
1789         testSubject = createTestSubject();
1790         boolean result = Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue",
1791             new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1792         assertThat(result).isTrue();
1793         assertEquals(hpdUpd.getCurrentValue(), hpdOrig.getCurrentValue());
1794     }
1795
1796
1797     @Test
1798     public void testExtractArtifactDefinition() throws Exception {
1799         ArtifactsBusinessLogic testSubject;
1800         ArtifactDefinition artifactDefinition = buildArtifactPayload();
1801         Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1802         ArtifactDefinition result;
1803
1804         // default test
1805         testSubject = createTestSubject();
1806         result = testSubject.extractArtifactDefinition(eitherArtifact);
1807         assertNotNull(result);
1808         assertEquals(artifactDefinition, result);
1809     }
1810
1811
1812     @Test
1813     public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1814         ArtifactsBusinessLogic testSubject;
1815         ArtifactDefinition artifact = buildArtifactPayload();
1816         ArtifactDefinition artifactInfo = new ArtifactDefinition();
1817
1818         HeatParameterDefinition hpdOrig = new HeatParameterDefinition();
1819         hpdOrig.setName("param1");
1820         hpdOrig.setCurrentValue("value1");
1821         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1822         currentHeatEnvParams.add(hpdOrig);
1823         artifact.setListHeatParameters(currentHeatEnvParams);
1824
1825         // default test
1826         testSubject = createTestSubject();
1827         Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1828             artifact, artifactInfo);
1829
1830         assertNotEquals(artifact, artifactInfo);
1831         assertEquals(1, artifact.getListHeatParameters().size());
1832         assertEquals(1, artifactInfo.getListHeatParameters().size());
1833
1834         String hpdOrigCurrValue = artifact.getListHeatParameters().get(0).getCurrentValue();
1835         String hpdNewDefaultValue = artifactInfo.getListHeatParameters().get(0).getDefaultValue();
1836
1837         assertEquals(hpdOrigCurrValue, hpdNewDefaultValue);
1838     }
1839
1840     @Test
1841     public void testBuildHeatEnvFileNameArtifactNameNotNull() throws Exception {
1842         String heatEnvExt = "zip";
1843         ArtifactsBusinessLogic testSubject;
1844         ArtifactDefinition heatArtifact = buildArtifactPayload();
1845         ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1846         Map<String, Object> placeHolderData = new HashMap<>();
1847         placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1848         String artName = ARTIFACT_NAME.split("\\.")[0];
1849
1850         // default test
1851         testSubject = createTestSubject();
1852         Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1853         assertThat(heatEnvArtifact.getArtifactName().startsWith(artName)).isTrue();
1854         assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1855     }
1856
1857     @Test
1858     public void testBuildHeatEnvFileNameArtifactNameIsNull() throws Exception {
1859         String heatEnvExt = "zip";
1860         ArtifactsBusinessLogic testSubject;
1861         ArtifactDefinition heatArtifact = buildArtifactPayload();
1862         heatArtifact.setArtifactName(null);
1863         ArtifactDefinition heatEnvArtifact = new ArtifactDefinition();
1864         Map<String, Object> placeHolderData = new HashMap<>();
1865         placeHolderData.put(ARTIFACT_PLACEHOLDER_FILE_EXTENSION, heatEnvExt);
1866
1867         // default test
1868         testSubject = createTestSubject();
1869         Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{heatArtifact, heatEnvArtifact, placeHolderData});
1870         assertThat(heatEnvArtifact.getArtifactName().startsWith(ARTIFACT_LABEL)).isTrue();
1871         assertThat(heatEnvArtifact.getArtifactName().endsWith(heatEnvExt)).isTrue();
1872     }
1873
1874     @Test
1875     public void testHandleEnvArtifactVersion() throws Exception {
1876         ArtifactsBusinessLogic testSubject;
1877         String existingVersion = "1.0";
1878         ArtifactDefinition artifactInfo = buildArtifactPayload();
1879         Map<String, String> existingEnvVersions = new HashMap<>();
1880         existingEnvVersions.put(artifactInfo.getArtifactName(), existingVersion);
1881
1882         // test 1
1883         testSubject = createTestSubject();
1884         Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", artifactInfo, existingEnvVersions);
1885         assertEquals(existingVersion, artifactInfo.getArtifactVersion());
1886     }
1887
1888     @Test
1889     public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1890         ArtifactsBusinessLogic testSubject;
1891         List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();
1892         Resource component = createResourceObject(true);
1893
1894         List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();
1895         ArtifactsBusinessLogic arb = getTestSubject();
1896         ArtifactOperationInfo operation = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1897         boolean shouldLock = false;
1898         boolean inTransaction = false;
1899         List<ArtifactDefinition> result;
1900
1901         // default test
1902         testSubject = createTestSubject();
1903         result = testSubject.handleArtifactsForInnerVfcComponent(artifactsToHandle, component, user,
1904             vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1905
1906         assertThat(CollectionUtils.isEmpty(result)).isTrue();
1907     }
1908
1909     @Test
1910     public void testSetNodeTemplateOperation() throws Exception {
1911         ArtifactsBusinessLogic testSubject;
1912         NodeTemplateOperation nodeTemplateOperation = new NodeTemplateOperation();
1913
1914         // default test
1915         testSubject = createTestSubject();
1916         Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", nodeTemplateOperation);
1917         assertEquals(Deencapsulation.getField(testSubject, "nodeTemplateOperation"), nodeTemplateOperation);
1918     }
1919
1920
1921     @Test(expected = ComponentException.class)
1922     public void validateDeploymentArtifact_invalidComponentType() {
1923         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1924         Component component = new Resource();
1925         component.setComponentType(ComponentTypeEnum.PRODUCT);
1926         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1927         Deencapsulation
1928             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1929     }
1930
1931     @Test(expected = ComponentException.class)
1932     public void validateDeploymentArtifact_notConfiguredArtifactType() {
1933         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1934         Component component = new Resource();
1935         component.setComponentType(ComponentTypeEnum.RESOURCE);
1936         artifactDefinition.setArtifactType("NotConfiguredType");
1937         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1938         Deencapsulation
1939             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, component);
1940     }
1941
1942     @Test(expected = ComponentException.class)
1943     public void validateDeploymentArtifact_unsupportedResourceType() {
1944         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1945         artifactDefinition.setArtifactType(ArtifactTypeEnum.ANSIBLE_PLAYBOOK.getType());
1946         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1947         final Resource resourceComponent = new Resource();
1948         resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1949         resourceComponent.setResourceType(ResourceTypeEnum.ServiceProxy);
1950         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1951         Deencapsulation
1952             .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1953     }
1954
1955     @Test
1956     public void validateDeploymentArtifact_validArtifact() {
1957         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1958         artifactDefinition.setArtifactType(ArtifactTypeEnum.YANG.getType());
1959         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1960         final Resource resourceComponent = new Resource();
1961         resourceComponent.setComponentType(ComponentTypeEnum.RESOURCE);
1962         resourceComponent.setResourceType(ResourceTypeEnum.VF);
1963         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1964         assertThatCode(() -> {
1965             Deencapsulation
1966                 .invoke(artifactsBusinessLogic, "validateDeploymentArtifact", artifactDefinition, resourceComponent);
1967         }).doesNotThrowAnyException();
1968
1969     }
1970
1971     @Test
1972     public void validateHeatArtifact_validArtifact() {
1973         final ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1974         artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
1975         artifactDefinition.setTimeout(1);
1976         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
1977         assertThatCode(() -> {
1978             Deencapsulation
1979                 .invoke(artifactsBusinessLogic, "validateHeatArtifact", new Resource(), "componentId", artifactDefinition);
1980         }).doesNotThrowAnyException();
1981     }
1982
1983     @Test
1984     public void validateInputForResourceInstance() {
1985         final String artifactId = "artifactId";
1986         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1987         artifactDefinition.setUniqueId(artifactId);
1988         artifactDefinition.setArtifactName(ARTIFACT_NAME);
1989         artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
1990         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
1991         artifactDefinition.setEsId(ES_ARTIFACT_ID);
1992         artifactDefinition.setPayload(PAYLOAD);
1993         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL);
1994         artifactDefinition.setDescription("artifact description");
1995         artifactDefinition.setServiceApi(true);
1996         artifactDefinition.setApiUrl("dumbUrl");
1997
1998         final User user = new User();
1999         user.setUserId("userId");
2000         user.setRole(Role.ADMIN.name());
2001
2002         final String parentId = "parentId";
2003         final Service service = new Service();
2004         service.setComponentType(ComponentTypeEnum.SERVICE);
2005         service.setUniqueId(parentId);
2006         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2007         service.setLastUpdaterUserId(user.getUserId());
2008
2009         final ArtifactOperationInfo operationInfo =
2010             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2011
2012         final String componentId = "componentId";
2013         final ComponentInstance componentInstance = new ComponentInstance();
2014         componentInstance.setUniqueId(componentId);
2015         componentInstance.setComponentUid(componentId);
2016         service.setComponentInstances(Collections.singletonList(componentInstance));
2017
2018         final Resource resource = new Resource();
2019         when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2020         when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2021
2022         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2023         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2024         Object result = Deencapsulation
2025             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2026                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2027         assertTrue(result instanceof Either<?, ?>);
2028         assertTrue(((Either<?, ?>) result).isLeft());
2029
2030         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2031
2032         result = Deencapsulation
2033             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2034                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2035         assertTrue(result instanceof Either<?, ?>);
2036         assertTrue(((Either<?, ?>) result).isLeft());
2037     }
2038
2039     @Test
2040     public void validateInputForResourceInstanceDeploymentArtifact() {
2041         final String artifactId = "artifactId";
2042         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2043         artifactDefinition.setUniqueId(artifactId);
2044         artifactDefinition.setArtifactName(ARTIFACT_NAME);
2045         artifactDefinition.setArtifactType(ArtifactTypeEnum.SNMP_POLL.getType());
2046         artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
2047         artifactDefinition.setEsId(ES_ARTIFACT_ID);
2048         artifactDefinition.setPayload(PAYLOAD);
2049         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2050         artifactDefinition.setDescription("artifact description");
2051
2052         final User user = new User();
2053         user.setUserId("userId");
2054         user.setRole(Role.ADMIN.name());
2055
2056         final String parentId = "parentId";
2057         final Service service = new Service();
2058         service.setComponentType(ComponentTypeEnum.SERVICE);
2059         service.setUniqueId(parentId);
2060         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2061         service.setLastUpdaterUserId(user.getUserId());
2062
2063         final ArtifactOperationInfo operationInfo =
2064             new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
2065
2066         final String componentId = "componentId";
2067         final ComponentInstance componentInstance = new ComponentInstance();
2068         componentInstance.setUniqueId(componentId);
2069         componentInstance.setComponentUid(componentId);
2070         service.setComponentInstances(Collections.singletonList(componentInstance));
2071
2072         final Resource resource = new Resource();
2073         when(toscaOperationFacade.getToscaFullElement(componentId)).thenReturn(Either.left(resource));
2074         when(artifactToscaOperation.getAllInstanceArtifacts(parentId, componentId)).thenReturn(Either.left(new HashMap<>()));
2075
2076         final ArtifactsBusinessLogic artifactsBusinessLogic = getTestSubject();
2077         artifactsBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
2078
2079         final Object result = Deencapsulation
2080             .invoke(artifactsBusinessLogic, "validateInput", componentId, artifactDefinition, operationInfo, artifactId,
2081                 user, "interfaceName", ARTIFACT_LABEL, ComponentTypeEnum.RESOURCE_INSTANCE, service);
2082         assertTrue(result instanceof Either<?, ?>);
2083         assertTrue(((Either<?, ?>) result).isLeft());
2084     }
2085
2086
2087     @Test
2088     public void testHandleArtifactRequest() {
2089
2090         String componentId = "componentId";
2091         ArtifactOperationInfo operationInfo = new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE);
2092         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2093         artifactDefinition.setArtifactName("other");
2094         artifactDefinition.setUniqueId("artifactId");
2095         artifactDefinition.setPayload("Test".getBytes());
2096         artifactDefinition.setArtifactLabel("other");
2097         artifactDefinition.setDescription("Test artifact");
2098         artifactDefinition.setArtifactType(ArtifactTypeEnum.OTHER.getType());
2099         artifactDefinition.setArtifactUUID("artifactUId");
2100         artifactDefinition.setArtifactLabel("test");
2101         artifactDefinition.setArtifactDisplayName("Test");
2102         artifactDefinition.setEsId("esId");
2103
2104         String requestMd5 = GeneralUtility.calculateMD5Base64EncodedByString("data");
2105         User user = new User();
2106         user.setUserId("userId");
2107
2108         List<ComponentInstance> componentInstanceList = new ArrayList<>();
2109         List<InterfaceDefinition> interfaceDefinitionsList = new ArrayList<>();
2110         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2111         Map<String, Operation> operationsMap = new HashMap<>();
2112         artifactDefinitionMap.put("sample", artifactDefinition);
2113
2114         ComponentInstance componentInstance = new ComponentInstance();
2115         componentInstance.setUniqueId(componentId);
2116         componentInstance.setDeploymentArtifacts(artifactDefinitionMap);
2117         componentInstanceList.add(componentInstance);
2118
2119         Operation operation = new Operation();
2120         operation.setUniqueId("ouuid");
2121         operation.setName("operation1");
2122         operation.setImplementation(artifactDefinition);
2123         operationsMap.put("op1", operation);
2124
2125         Map<String, InterfaceDefinition> interfaceDefinitions = new HashMap<>();
2126
2127         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2128         interfaceDefinition.setType("iuuid");
2129         interfaceDefinition.setOperationsMap(operationsMap);
2130         interfaceDefinitions.put("iuuid", interfaceDefinition);
2131
2132         interfaceDefinitionsList.add(interfaceDefinition);
2133
2134         ResourceMetadataDataDefinition resourceMetadaData = new ResourceMetadataDataDefinition();
2135         resourceMetadaData.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
2136         resourceMetadaData.setLastUpdaterUserId(user.getUserId());
2137         Resource resource = new Resource(new ResourceMetadataDefinition(resourceMetadaData));
2138         resource.setComponentInstances(componentInstanceList);
2139         resource.setUniqueId(componentId);
2140         resource.setInterfaces(interfaceDefinitions);
2141
2142         user.setRole(Role.ADMIN.name());
2143
2144         when(userValidations.validateUserExists(Mockito.eq("userId")))
2145             .thenReturn(user);
2146         when(toscaOperationFacade.getToscaFullElement(any()))
2147             .thenReturn(Either.left(resource));
2148         when(artifactToscaOperation.getArtifactById(any(), any(), any(), any()))
2149             .thenReturn(Either.left(artifactDefinition));
2150         when(artifactsResolver.findArtifactOnComponent(any(), any(ComponentTypeEnum.class), anyString()))
2151             .thenReturn(artifactDefinition);
2152         when(graphLockOperation.lockComponent(eq(resource.getUniqueId()), any(NodeTypeEnum.class)))
2153             .thenReturn(StorageOperationStatus.OK);
2154         when(artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(), anyString(), any(NodeTypeEnum.class), any(),
2155             anyBoolean()))
2156             .thenReturn(Either.left(artifactDefinition));
2157         when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class))).thenReturn(CassandraOperationStatus.OK);
2158         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
2159         when(interfaceOperation.updateInterfaces(any(Component.class), anyList())).thenReturn(Either.left(interfaceDefinitionsList));
2160         when(artifactToscaOperation.getAllInstanceArtifacts(resource.getUniqueId(), componentId)).thenReturn(Either.left(artifactDefinitionMap));
2161         when(toscaOperationFacade.generateCustomizationUUIDOnInstance(any(), any())).thenReturn(StorageOperationStatus.OK);
2162
2163         Either<ArtifactDefinition, Operation> result = artifactBL.handleArtifactRequest(componentId, user.getUserId(),
2164             ComponentTypeEnum.RESOURCE_INSTANCE
2165             , operationInfo, artifactDefinition.getUniqueId(), artifactDefinition, requestMd5, "data", "iuuid",
2166             null, componentId, "resources");
2167
2168         assertThat(result.isLeft()).isTrue();
2169         ArtifactDefinition leftValue = result.left().value();
2170         assertEquals(artifactDefinition.getArtifactName(), leftValue.getArtifactName());
2171     }
2172
2173     @Test
2174     public void testGenerateToscaArtifact() {
2175
2176         Resource resource = new Resource();
2177         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2178         resource.setUniqueId("resourceId");
2179
2180         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2181         artifactDefinition.setUniqueId("artifactId");
2182         artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_CSAR.getType());
2183         User user = new User();
2184         boolean inCertificationRequest = false;
2185         boolean fetchTemplatesFromDB = false;
2186         boolean shouldLock = false;
2187         boolean inTransaction = false;
2188
2189         byte[] csar = "test.csar".getBytes();
2190
2191         when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2192             .thenReturn(Either.left(csar));
2193         when(
2194             artifactToscaOperation.updateArtifactOnResource(any(ArtifactDefinition.class), any(Component.class), anyString(), any(NodeTypeEnum.class),
2195                 anyString(), anyBoolean()))
2196             .thenReturn(Either.left(artifactDefinition));
2197         when(artifactCassandraDao.saveArtifact(any(DAOArtifactData.class)))
2198             .thenReturn(CassandraOperationStatus.OK);
2199
2200         Either<ArtifactDefinition, Operation> result
2201             = artifactBL.generateAndSaveToscaArtifact(artifactDefinition, resource, user, inCertificationRequest,
2202             shouldLock, inTransaction, fetchTemplatesFromDB);
2203
2204         Assert.assertEquals(artifactDefinition.getUniqueId(), result.left().value().getUniqueId());
2205     }
2206
2207     @Test
2208     public void testHandleDownloadToscaModelRequest() {
2209         ArtifactsBusinessLogic testSubject = getTestSubject();
2210         byte[] generatedCsar = "test.csar".getBytes();
2211
2212         Resource resource = new Resource();
2213         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2214
2215         ArtifactDefinition csarArtifact = new ArtifactDefinition();
2216         csarArtifact.setArtifactName("csarArtifact");
2217         csarArtifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.getType());
2218         csarArtifact.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2219
2220         when(csarUtils.createCsar(any(Component.class), anyBoolean(), anyBoolean()))
2221             .thenReturn(Either.left(generatedCsar));
2222
2223         ImmutablePair<String, byte[]> result =
2224             testSubject.handleDownloadToscaModelRequest(resource, csarArtifact);
2225
2226         assertEquals(csarArtifact.getArtifactName(), result.getKey());
2227     }
2228
2229     @Test
2230     public void testHandleDownloadRequestById_returnsSuccessful() {
2231         String componentId = "componentId";
2232         String artifactId = "artifactId";
2233         String parentId = "parentId";
2234
2235         DAOArtifactData daoArtifactData = new DAOArtifactData();
2236         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2237         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2238         Operation operation = new Operation();
2239         operation.setUniqueId("op1");
2240
2241         artifactDefinition.setArtifactName("test.csar");
2242         artifactDefinition.setArtifactType(ComponentTypeEnum.RESOURCE.name());
2243         artifactDefinition.setArtifactType(ArtifactTypeEnum.HEAT.getType());
2244         artifactDefinition.setUniqueId(artifactId);
2245         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
2246
2247         daoArtifactData.setDataAsArray("data".getBytes());
2248
2249         Resource resource = new Resource();
2250         resource.setUniqueId("resourceId");
2251         resource.setAbstract(false);
2252
2253         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2254         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
2255         interfaceDefinitionMap.put("interDef1", interfaceDefinition);
2256
2257         artifactDefinitionMap.put("artifact1", artifactDefinition);
2258
2259         resource.setDeploymentArtifacts(artifactDefinitionMap);
2260
2261         User user = new User();
2262         user.setUserId("userId");
2263
2264         when(userValidations.validateUserExists(eq(user.getUserId())))
2265             .thenReturn(user);
2266         when(toscaOperationFacade.getToscaFullElement(eq(componentId)))
2267             .thenReturn(Either.left(resource));
2268         when(artifactToscaOperation.getArtifactById(anyString(), anyString(), any(ComponentTypeEnum.class), anyString()))
2269             .thenReturn(Either.left(artifactDefinition));
2270         when(artifactCassandraDao.getArtifact(any()))
2271             .thenReturn(Either.left(daoArtifactData));
2272         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
2273
2274         ImmutablePair<String, byte[]> result =
2275             artifactBL.handleDownloadRequestById(componentId, artifactId, user.getUserId(), ComponentTypeEnum.RESOURCE,
2276                 parentId, null);
2277         Assert.assertEquals(artifactDefinition.getArtifactName(), result.getKey());
2278     }
2279
2280     @Test
2281     public void testHandleDownloadRequestById_givenUserIdIsNull_thenReturnsError() {
2282         String componentId = "componentId";
2283         String userId = null;
2284         String artifactId = "artifactId";
2285
2286         try {
2287             ImmutablePair<String, byte[]> result =
2288                 artifactBL.handleDownloadRequestById(componentId, artifactId, userId, ComponentTypeEnum.RESOURCE, componentId
2289                     , null);
2290         } catch (ComponentException e) {
2291             assertEquals(e.getActionStatus(), ActionStatus.MISSING_INFORMATION);
2292             return;
2293         }
2294         fail();
2295     }
2296
2297     @Test
2298     public void testHandleGetArtifactByType_returnsSuccessful() {
2299         String parentId = "parentId";
2300         String componentId = "componentId";
2301         String artifactGroupType = ArtifactGroupTypeEnum.OTHER.name();
2302         String userId = "userId";
2303
2304         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2305         artifactDefinition.setArtifactName("test.csar");
2306
2307         Map<String, ArtifactDefinition> artifactDefinitionMap = new HashMap<>();
2308         artifactDefinitionMap.put("artifact1", artifactDefinition);
2309
2310         Service service = new Service();
2311         service.setUniqueId(componentId);
2312
2313         when(toscaOperationFacade.getToscaElement(eq(componentId), any(ComponentParametersView.class)))
2314             .thenReturn(Either.left(service));
2315         when(graphLockOperation.lockComponent(eq(componentId), any(NodeTypeEnum.class)))
2316             .thenReturn(StorageOperationStatus.OK);
2317         when(artifactToscaOperation.getArtifacts(any(), any(NodeTypeEnum.class), any(ArtifactGroupTypeEnum.class), any()))
2318             .thenReturn(Either.left(artifactDefinitionMap));
2319
2320         Map<String, ArtifactDefinition> result =
2321             artifactBL.handleGetArtifactsByType(ComponentTypeEnum.SERVICE.name(), parentId, ComponentTypeEnum.SERVICE,
2322                 componentId, artifactGroupType, userId);
2323         Assert.assertEquals(artifactDefinition.getArtifactName(), result.get("artifact1").getArtifactName());
2324     }
2325
2326     @Test
2327     public void testGetDeployment_returnsSuccessful() {
2328
2329         Resource resource = new Resource();
2330         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2331         ComponentInstance componentInstance = new ComponentInstance();
2332         NodeTypeEnum parentType = NodeTypeEnum.ResourceInstance;
2333         String ciId = "ciId";
2334
2335         artifactDefinition.setArtifactName("test.csar");
2336         componentInstance.setUniqueId(ciId);
2337         List<ComponentInstance> componentInstanceList = new ArrayList<>();
2338         componentInstanceList.add(componentInstance);
2339
2340         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2341         deploymentArtifacts.put("test.csar", artifactDefinition);
2342
2343         resource.setDeploymentArtifacts(deploymentArtifacts);
2344         resource.setComponentInstances(componentInstanceList);
2345         componentInstance.setDeploymentArtifacts(deploymentArtifacts);
2346
2347         List<ArtifactDefinition> result = artifactBL.getDeploymentArtifacts(resource, ciId);
2348         assertThat(result.size() == 1).isTrue();
2349         Assert.assertEquals(artifactDefinition.getArtifactName(), result.get(0).getArtifactName());
2350     }
2351
2352     @Test
2353     public void testHandleDelete_returnsSuccessful() {
2354
2355         String parentId = "parentId";
2356         String artifactId = "artifactId";
2357         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2358         Resource resource = new Resource();
2359         User user = new User();
2360
2361         artifactDefinition.setArtifactName("test.csar");
2362         artifactDefinition.setUniqueId(artifactId);
2363         artifactDefinition.setEsId("esId");
2364
2365         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
2366
2367         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
2368         deploymentArtifacts.put(artifactId, artifactDefinition);
2369
2370         resource.setUniqueId(parentId);
2371         resource.setComponentType(ComponentTypeEnum.RESOURCE);
2372         resource.setDeploymentArtifacts(deploymentArtifacts);
2373
2374         when(graphLockOperation.lockComponent(eq(parentId), any(NodeTypeEnum.class)))
2375             .thenReturn(StorageOperationStatus.OK);
2376         when(toscaOperationFacade.getToscaElement(eq(parentId)))
2377             .thenReturn(Either.left(resource));
2378         when(artifactToscaOperation.isCloneNeeded(any(), any(ArtifactDefinition.class), any(NodeTypeEnum.class)))
2379             .thenReturn(Either.left(Boolean.FALSE));
2380         when(artifactToscaOperation.removeArtifactOnGraph(any(ArtifactDefinition.class), any(), any(), any(NodeTypeEnum.class), anyBoolean()))
2381             .thenReturn(Either.left(artifactDataDefinition));
2382         when(artifactCassandraDao.deleteArtifact(any()))
2383             .thenReturn(CassandraOperationStatus.OK);
2384
2385         Either<ArtifactDefinition, ResponseFormat> result = artifactBL.handleDelete(
2386             parentId, artifactId, user, resource, true, false);
2387         Assert.assertEquals(artifactDefinition.getArtifactName(), result.left().value().getArtifactName());
2388     }
2389
2390     @Test
2391     public void testDownloadRsrcArtifactByNames_givenServiceNameNull_thenReturnsError() {
2392         String serviceName = null;
2393         String serviceVersion = "2.0";
2394         String resourceName = "resource";
2395         String resourceVersion = "1.0";
2396         String artifactName = "artifactName";
2397
2398         try {
2399             artifactBL.downloadRsrcArtifactByNames(serviceName, serviceVersion, resourceName, resourceVersion, artifactName);
2400         } catch (ComponentException e) {
2401             assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
2402             return;
2403         }
2404         fail();
2405
2406     }
2407
2408     @Test
2409     public void testDownloadRsrcArtifactByNames_returnsSuccessful() {
2410
2411         String serviceName = "service1";
2412         String resourceName = "resource1";
2413         String artifactName = "artifact1";
2414         String version = "1.0";
2415
2416         Resource resource = new Resource();
2417         resource.setName(resourceName);
2418         resource.setVersion(version);
2419
2420         Service service = new Service();
2421         service.setVersion(version);
2422         service.setName(serviceName);
2423
2424         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2425         artifactDefinition.setEsId("esId");
2426
2427         DAOArtifactData esArtifactData = new DAOArtifactData();
2428         esArtifactData.setDataAsArray("test".getBytes());
2429
2430         artifactDefinition.setArtifactName(artifactName);
2431         List<Service> serviceList = new ArrayList<>();
2432         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2433         artifacts.put(artifactName, artifactDefinition);
2434
2435         serviceList.add(service);
2436         resource.setDeploymentArtifacts(artifacts);
2437
2438         when(toscaOperationFacade.getComponentByNameAndVersion(eq(ComponentTypeEnum.RESOURCE), eq(resourceName), eq(version),
2439             eq(JsonParseFlagEnum.ParseMetadata)))
2440             .thenReturn(Either.left(resource));
2441         doReturn(Either.left(serviceList)).when(toscaOperationFacade).getBySystemName(eq(ComponentTypeEnum.SERVICE), eq(serviceName));
2442         when(artifactCassandraDao.getArtifact(any()))
2443             .thenReturn(Either.left(esArtifactData));
2444
2445         byte[] result = artifactBL.downloadRsrcArtifactByNames(serviceName, version, resourceName, version, artifactName);
2446         Assert.assertEquals(esArtifactData.getDataAsArray(), result);
2447     }
2448
2449     private ArtifactsBusinessLogic getTestSubject() {
2450         final ArtifactsBusinessLogic artifactsBusinessLogic = new ArtifactsBusinessLogic(artifactCassandraDao,
2451             toscaExportHandler, csarUtils, lifecycleBusinessLogic,
2452             userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation,
2453             groupTypeOperation,
2454             interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation, artifactTypeOperation);
2455         artifactsBusinessLogic.setComponentsUtils(componentsUtils);
2456         return artifactsBusinessLogic;
2457     }
2458 }