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