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