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

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