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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import com.fasterxml.jackson.annotation.JsonInclude;
  24 import com.fasterxml.jackson.databind.DeserializationFeature;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import com.fasterxml.jackson.databind.SerializationFeature;
  27 import com.google.gson.Gson;
  28 import com.google.gson.GsonBuilder;
  29 import com.google.gson.JsonElement;
  30 import fj.data.Either;
  31 import mockit.Deencapsulation;
  32 import org.apache.commons.codec.binary.Base64;
  33 import org.apache.commons.lang3.tuple.ImmutablePair;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.mockito.InjectMocks;
  37 import org.mockito.Mock;
  38 import org.mockito.Mockito;
  39 import org.mockito.MockitoAnnotations;
  40 import org.openecomp.sdc.be.MockGenerator;
  41 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  42 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo;
  43 import org.openecomp.sdc.be.components.utils.ArtifactBuilder;
  44 import org.openecomp.sdc.be.components.utils.ObjectGenerator;
  45 import org.openecomp.sdc.be.config.Configuration.ArtifactTypeConfig;
  46 import org.openecomp.sdc.be.config.ConfigurationManager;
  47 import org.openecomp.sdc.be.dao.api.ActionStatus;
  48 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  49 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  50 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  51 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  52 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  55 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  57 import org.openecomp.sdc.be.impl.ComponentsUtils;
  58 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
  59 import org.openecomp.sdc.be.model.ArtifactDefinition;
  60 import org.openecomp.sdc.be.model.ArtifactType;
  61 import org.openecomp.sdc.be.model.Component;
  62 import org.openecomp.sdc.be.model.ComponentInstance;
  63 import org.openecomp.sdc.be.model.DataTypeDefinition;
  64 import org.openecomp.sdc.be.model.GroupDefinition;
  65 import org.openecomp.sdc.be.model.GroupInstance;
  66 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  67 import org.openecomp.sdc.be.model.InterfaceDefinition;
  68 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  69 import org.openecomp.sdc.be.model.Operation;
  70 import org.openecomp.sdc.be.model.Resource;
  71 import org.openecomp.sdc.be.model.Service;
  72 import org.openecomp.sdc.be.model.User;
  73 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  74 import org.openecomp.sdc.be.model.jsontitan.operations.ArtifactsOperations;
  75 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
  76 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  77 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  78 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  79 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  80 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  81 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  82 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
  83 import org.openecomp.sdc.be.resources.data.ESArtifactData;
  84 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  85 import org.openecomp.sdc.be.servlets.RepresentationUtils;
  86 import org.openecomp.sdc.be.user.Role;
  87 import org.openecomp.sdc.be.user.UserBusinessLogic;
  88 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  89 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  90 import org.openecomp.sdc.common.api.ConfigurationSource;
  91 import org.openecomp.sdc.common.datastructure.Wrapper;
  92 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  93 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  94 import org.openecomp.sdc.exception.ResponseFormat;
  95
  96 import java.io.IOException;
  97 import java.util.ArrayList;
  98 import java.util.Collections;
  99 import java.util.HashMap;
 100 import java.util.List;
 101 import java.util.Map;
 102
 103 import static org.junit.Assert.assertArrayEquals;
 104 import static org.junit.Assert.assertEquals;
 105 import static org.junit.Assert.assertNull;
 106 import static org.junit.Assert.assertTrue;
 107 import static org.mockito.ArgumentMatchers.any;
 108 import static org.mockito.ArgumentMatchers.anyBoolean;
 109 import static org.mockito.ArgumentMatchers.anyString;
 110 import static org.mockito.ArgumentMatchers.eq;
 111 import static org.mockito.Mockito.times;
 112 import static org.mockito.Mockito.verify;
 113 import static org.mockito.Mockito.when;
 114 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_ENV_NAME;
 115 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.HEAT_VF_ENV_NAME;
 116
 117 public class ArtifactsBusinessLogicTest {
 118
 119         public static final User USER = new User("John", "Doh", "jh0003", "jh0003@gmail.com", "ADMIN",
 120                         System.currentTimeMillis());
 121         private final static String RESOURCE_INSTANCE_NAME = "Service-111";
 122         private final static String INSTANCE_ID = "S-123-444-ghghghg";
 123
 124         private final static String ARTIFACT_NAME = "service-Myservice-template.yml";
 125         private final static String ARTIFACT_LABEL = "assettoscatemplate";
 126         private final static String ES_ARTIFACT_ID = "123123dfgdfgd0";
 127         private final static byte[] PAYLOAD = "some payload".getBytes();
 128         public static final String RESOURCE_NAME = "My-Resource_Name with   space";
 129         public static final String RESOURCE_CATEGORY = "Network Layer 2-3/Router";
 130         public static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 131         public static final String RESOURCE_SUBCATEGORY = "Router";
 132         final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 133
 134         TitanDao mockTitanDao = Mockito.mock(TitanDao.class);
 135
 136         static ConfigurationSource configurationSource = new FSConfigurationSource(
 137                         ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
 138         static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 139
 140         @InjectMocks
 141         private static ArtifactsBusinessLogic artifactBL;
 142
 143         private static User user = null;
 144         private static Resource resourceResponse = null;
 145         private static ResponseFormatManager responseManager = null;
 146
 147         @Mock
 148         private UserBusinessLogic userBusinessLogic;
 149         @Mock
 150         private ArtifactOperation artifactOperation;
 151         @Mock
 152         public ComponentsUtils componentsUtils;
 153         @Mock
 154         private IInterfaceLifecycleOperation lifecycleOperation;
 155         @Mock
 156         private IUserAdminOperation userOperation;
 157         @Mock
 158         private IElementOperation elementOperation;
 159         @Mock
 160         private ArtifactCassandraDao artifactCassandraDao;
 161         @Mock
 162         public ToscaOperationFacade toscaOperationFacade;
 163         @Mock
 164         private NodeTemplateOperation nodeTemplateOperation;
 165         @Mock
 166         private ArtifactsOperations artifactsOperations;
 167         @Mock
 168         private IGraphLockOperation graphLockOperation;
 169         @Mock
 170         TitanDao titanDao;
 171
 172         public static final Resource resource = Mockito.mock(Resource.class);
 173         private Gson gson = new GsonBuilder().setPrettyPrinting().create();
 174
 175         private static List<ArtifactType> getAllTypes() {
 176                 List<ArtifactType> artifactTypes = new ArrayList<>();
 177                 List<String> artifactTypesList = ConfigurationManager.getConfigurationManager().getConfiguration()
 178                                 .getArtifactTypes();
 179                 for (String artifactType : artifactTypesList) {
 180                         ArtifactType artifactT = new ArtifactType();
 181                         artifactT.setName(artifactType);
 182                         artifactTypes.add(artifactT);
 183                 }
 184                 return artifactTypes;
 185         }
 186
 187         @Before
 188         public void initMocks() {
 189                 MockitoAnnotations.initMocks(this);
 190                 Either<ArtifactDefinition, StorageOperationStatus> NotFoundResult = Either
 191                                 .right(StorageOperationStatus.NOT_FOUND);
 192
 193                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> NotFoundResult2 = Either
 194                                 .right(StorageOperationStatus.NOT_FOUND);
 195                 when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Service), Mockito.anyBoolean()))
 196                                 .thenReturn(NotFoundResult2);
 197                 when(artifactOperation.getArtifacts(Mockito.anyString(), eq(NodeTypeEnum.Resource), Mockito.anyBoolean()))
 198                                 .thenReturn(NotFoundResult2);
 199
 200                 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> notFoundInterfaces = Either
 201                                 .right(StorageOperationStatus.NOT_FOUND);
 202                 when(lifecycleOperation.getAllInterfacesOfResource(Mockito.anyString(), Mockito.anyBoolean()))
 203                                 .thenReturn(notFoundInterfaces);
 204
 205                 Either<User, ActionStatus> getUserResult = Either.left(USER);
 206
 207                 when(userOperation.getUserData("jh0003", false)).thenReturn(getUserResult);
 208
 209                 Either<List<ArtifactType>, ActionStatus> getType = Either.left(getAllTypes());
 210                 when(elementOperation.getAllArtifactTypes()).thenReturn(getType);
 211
 212                 when(resource.getResourceType()).thenReturn(ResourceTypeEnum.VFC);
 213
 214                 // User data and management
 215                 user = new User();
 216                 user.setUserId("jh0003");
 217                 user.setFirstName("Jimmi");
 218                 user.setLastName("Hendrix");
 219                 user.setRole(Role.ADMIN.name());
 220
 221                 // createResource
 222                 resourceResponse = createResourceObject(true);
 223                 Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 224                 when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 225                 when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(StorageOperationStatus.OK);
 226                 Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 227                 when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 228                 when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK);
 229
 230                 Either<Component, StorageOperationStatus> resourceStorageOperationStatusEither = Either
 231                                 .right(StorageOperationStatus.BAD_REQUEST);
 232                 when(toscaOperationFacade.getToscaElement(resourceResponse.getUniqueId()))
 233                                 .thenReturn(resourceStorageOperationStatusEither);
 234         }
 235
 236         @Test
 237         public void testValidJson() {
 238                 ArtifactDefinition ad = createArtifactDef();
 239
 240                 String jsonArtifact = "";
 241
 242                 ObjectMapper mapper = new ObjectMapper();
 243                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 244                 mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 245                 mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 246
 247                 try {
 248                         jsonArtifact = mapper.writeValueAsString(ad);
 249                 } catch (IOException e) {
 250                         // TODO Auto-generated catch block
 251                         e.printStackTrace();
 252                 }
 253
 254                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact,
 255                                 ArtifactDefinition.class);
 256                 assertEquals(ad, afterConvert);
 257         }
 258
 259         private ArtifactDefinition createArtifactDef() {
 260                 ArtifactDefinition ad = new ArtifactDefinition();
 261                 ad.setArtifactName("artifact1.yaml");
 262                 ad.setArtifactLabel("label1");
 263                 ad.setDescription("description");
 264                 ad.setArtifactType(ArtifactTypeEnum.HEAT.getType());
 265                 ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 266                 ad.setCreationDate(System.currentTimeMillis());
 267                 ad.setMandatory(false);
 268                 ad.setTimeout(15);
 269                 return ad;
 270         }
 271
 272         private Resource createResourceObject(boolean afterCreate) {
 273                 Resource resource = new Resource();
 274                 resource.setName(RESOURCE_NAME);
 275                 resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 276                 resource.setDescription("My short description");
 277                 List<String> tgs = new ArrayList<String>();
 278                 tgs.add("test");
 279                 tgs.add(resource.getName());
 280                 resource.setTags(tgs);
 281                 List<String> template = new ArrayList<String>();
 282                 template.add("Root");
 283                 resource.setDerivedFrom(template);
 284                 resource.setVendorName("Motorola");
 285                 resource.setVendorRelease("1.0.0");
 286                 resource.setContactId("ya5467");
 287                 resource.setIcon("MyIcon");
 288
 289                 if (afterCreate) {
 290                         resource.setName(resource.getName());
 291                         resource.setVersion("0.1");
 292                         resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 293                         resource.setCreatorUserId(user.getUserId());
 294                         resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 295                         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 296                 }
 297                 return resource;
 298         }
 299
 300         @Test
 301         public void testInvalidStringGroupType() {
 302                 ArtifactDefinition ad = new ArtifactDefinition();
 303                 ad.setArtifactName("artifact1");
 304                 ad.setCreationDate(System.currentTimeMillis());
 305                 ad.setMandatory(false);
 306                 ad.setTimeout(15);
 307
 308                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 309                 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", "www");
 310
 311                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 312                                 ArtifactDefinition.class);
 313                 assertNull(afterConvert);
 314         }
 315
 316         @Test
 317         public void testInvalidNumberGroupType() {
 318                 ArtifactDefinition ad = new ArtifactDefinition();
 319                 ad.setArtifactName("artifact1");
 320                 ad.setCreationDate(System.currentTimeMillis());
 321                 ad.setMandatory(false);
 322                 ad.setTimeout(15);
 323
 324                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 325                 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", 123);
 326
 327                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 328                                 ArtifactDefinition.class);
 329                 assertNull(afterConvert);
 330         }
 331
 332         @Test
 333         public void testInvalidGroupTypeWithSpace() {
 334                 ArtifactDefinition ad = new ArtifactDefinition();
 335                 ad.setArtifactName("artifact1");
 336                 ad.setCreationDate(System.currentTimeMillis());
 337                 ad.setMandatory(false);
 338                 ad.setTimeout(15);
 339
 340                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 341                 jsonArtifact.getAsJsonObject().addProperty("artifactGroupType", " DEPLOYMENT");
 342
 343                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 344                                 ArtifactDefinition.class);
 345                 assertNull(afterConvert);
 346         }
 347
 348         @Test
 349         public void testInvalidTimeoutWithSpace() {
 350                 ArtifactDefinition ad = new ArtifactDefinition();
 351                 ad.setArtifactName("artifact1");
 352                 ad.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 353                 ad.setCreationDate(System.currentTimeMillis());
 354                 ad.setMandatory(false);
 355
 356                 JsonElement jsonArtifact = gson.toJsonTree(ad);
 357                 jsonArtifact.getAsJsonObject().addProperty("timeout", "dfsdf15");
 358
 359                 ArtifactDefinition afterConvert = RepresentationUtils.convertJsonToArtifactDefinition(jsonArtifact.toString(),
 360                                 ArtifactDefinition.class);
 361                 assertNull(afterConvert);
 362         }
 363
 364         @Test
 365         public void testValidMibAritactsConfiguration() {
 366                 Map<String, ArtifactTypeConfig> componentDeploymentArtifacts = ConfigurationManager.getConfigurationManager()
 367                                 .getConfiguration().getResourceDeploymentArtifacts();
 368                 Map<String, ArtifactTypeConfig> componentInstanceDeploymentArtifacts = ConfigurationManager
 369                                 .getConfigurationManager().getConfiguration().getResourceInstanceDeploymentArtifacts();
 370                 assertTrue(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType()));
 371                 assertTrue(componentDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType()));
 372                 assertTrue(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_POLL.getType()));
 373                 assertTrue(componentInstanceDeploymentArtifacts.containsKey(ArtifactTypeEnum.SNMP_TRAP.getType()));
 374         }
 375
 376         @Test
 377         public void testDownloadServiceArtifactByNames() {
 378                 Service service = new Service();
 379                 String serviceName = "myService";
 380                 String serviceVersion = "1.0";
 381                 String serviceId = "serviceId";
 382                 service.setName(serviceName);
 383                 service.setVersion(serviceVersion);
 384                 service.setUniqueId(serviceId);
 385
 386                 String artifactName = "service-Myservice-template.yml";
 387                 String artifactLabel = "assettoscatemplate";
 388                 String esArtifactId = "123123dfgdfgd0";
 389                 byte[] payload = "some payload".getBytes();
 390                 ArtifactDefinition toscaTemplateArtifact = new ArtifactDefinition();
 391                 toscaTemplateArtifact.setArtifactName(artifactName);
 392                 toscaTemplateArtifact.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 393                 toscaTemplateArtifact.setArtifactLabel(artifactLabel);
 394                 toscaTemplateArtifact.setEsId(esArtifactId);
 395                 toscaTemplateArtifact.setPayload(payload);
 396
 397                 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 398                 toscaArtifacts.put(artifactLabel, toscaTemplateArtifact);
 399                 service.setToscaArtifacts(toscaArtifacts);
 400
 401                 ESArtifactData esArtifactData = new ESArtifactData(esArtifactId);
 402                 esArtifactData.setDataAsArray(payload);
 403                 Either<ESArtifactData, CassandraOperationStatus> artifactfromESres = Either.left(esArtifactData);
 404                 when(artifactCassandraDao.getArtifact(esArtifactId)).thenReturn(artifactfromESres);
 405                 List<org.openecomp.sdc.be.model.Component> serviceList = new ArrayList<>();
 406                 serviceList.add(service);
 407                 Either<List<org.openecomp.sdc.be.model.Component>, StorageOperationStatus> getServiceRes = Either
 408                                 .left(serviceList);
 409                 when(toscaOperationFacade.getBySystemName(ComponentTypeEnum.SERVICE, serviceName)).thenReturn(getServiceRes);
 410                 Either<byte[], ResponseFormat> downloadServiceArtifactByNamesRes = artifactBL
 411                                 .downloadServiceArtifactByNames(serviceName, serviceVersion, artifactName);
 412                 assertTrue(downloadServiceArtifactByNamesRes.isLeft());
 413                 assertTrue(downloadServiceArtifactByNamesRes.left().value() != null
 414                                 && downloadServiceArtifactByNamesRes.left().value().length == payload.length);
 415         }
 416
 417         @Test
 418         public void createHeatEnvPlaceHolder_vf_emptyHeatParameters() throws Exception {
 419                 ArtifactDefinition heatArtifact = new ArtifactBuilder()
 420                                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal1", "val1"))
 421                                 .addHeatParam(ObjectGenerator.buildHeatParam("defVal2", "val2")).build();
 422
 423                 Resource component = new Resource();
 424                 component.setComponentType(ComponentTypeEnum.RESOURCE);
 425                 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(Either.left(USER));
 426                 when(artifactsOperations.addHeatEnvArtifact(any(ArtifactDefinition.class), any(ArtifactDefinition.class),
 427                                 eq(component.getUniqueId()), eq(NodeTypeEnum.Resource), eq(true), eq("parentId")))
 428                                                 .thenReturn(Either.left(new ArtifactDefinition()));
 429                 Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 430                                 heatArtifact, HEAT_VF_ENV_NAME, "parentId", NodeTypeEnum.Resource, "parentName", USER, component,
 431                                 Collections.emptyMap());
 432                 assertTrue(heatEnvPlaceHolder.isLeft());
 433                 assertNull(heatEnvPlaceHolder.left().value().getListHeatParameters());
 434         }
 435
 436         @Test
 437         public void createHeatEnvPlaceHolder_resourceInstance_copyHeatParamasCurrValuesToHeatEnvDefaultVal()
 438                         throws Exception {
 439                 HeatParameterDefinition heatParam1 = ObjectGenerator.buildHeatParam("defVal1", "val1");
 440                 HeatParameterDefinition heatParam2 = ObjectGenerator.buildHeatParam("defVal2", "val2");
 441                 HeatParameterDefinition heatParam3 = ObjectGenerator.buildHeatParam("defVal3", "val3");
 442                 ArtifactDefinition heatArtifact = new ArtifactBuilder().addHeatParam(heatParam1).addHeatParam(heatParam2)
 443                                 .addHeatParam(heatParam3).build();
 444
 445                 Resource component = new Resource();
 446
 447                 when(userBusinessLogic.getUser(anyString(), anyBoolean())).thenReturn(Either.left(USER));
 448                 when(artifactsOperations.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
 452                 Either<ArtifactDefinition, ResponseFormat> heatEnvPlaceHolder = artifactBL.createHeatEnvPlaceHolder(
 453                                 heatArtifact, HEAT_ENV_NAME, "parentId", NodeTypeEnum.ResourceInstance, "parentName", USER, component,
 454                                 Collections.emptyMap());
 455
 456                 assertTrue(heatEnvPlaceHolder.isLeft());
 457                 ArtifactDefinition heatEnvArtifact = heatEnvPlaceHolder.left().value();
 458                 List<HeatParameterDefinition> listHeatParameters = heatEnvArtifact.getListHeatParameters();
 459                 assertEquals(listHeatParameters.size(), 3);
 460                 verifyHeatParam(listHeatParameters.get(0), heatParam1);
 461                 verifyHeatParam(listHeatParameters.get(1), heatParam2);
 462                 verifyHeatParam(listHeatParameters.get(2), heatParam3);
 463         }
 464
 465         @Test
 466         public void buildArtifactPayloadWhenShouldLockAndInTransaction() {
 467                 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 468                 artifactDefinition.setArtifactName(ARTIFACT_NAME);
 469                 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 470                 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 471                 artifactDefinition.setEsId(ES_ARTIFACT_ID);
 472                 artifactDefinition.setPayload(PAYLOAD);
 473                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 474
 475                 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 476                 when(artifactsOperations.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 477                                 any(NodeTypeEnum.class), any(String.class))).thenReturn(Either.left(artifactDefinition));
 478                 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 479                 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 480                 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 481                                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, true);
 482         }
 483
 484         @Test
 485         public void buildArtifactPayloadWhenShouldLockAndNotInTransaction() {
 486                 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 487                 artifactDefinition.setArtifactName(ARTIFACT_NAME);
 488                 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 489                 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 490                 artifactDefinition.setEsId(ES_ARTIFACT_ID);
 491                 artifactDefinition.setPayload(PAYLOAD);
 492                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 493
 494                 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 495                 when(artifactsOperations.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 496                                 any(NodeTypeEnum.class), any(String.class))).thenReturn(Either.left(artifactDefinition));
 497                 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 498                 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 499                 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 500                                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 501                 verify(titanDao, times(1)).commit();
 502         }
 503
 504
 505         private ArtifactDefinition buildArtifactPayload() {
 506                 ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 507                 artifactDefinition.setArtifactName(ARTIFACT_NAME);
 508                 artifactDefinition.setArtifactType(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 509                 artifactDefinition.setArtifactLabel(ARTIFACT_LABEL);
 510                 artifactDefinition.setEsId(ES_ARTIFACT_ID);
 511                 artifactDefinition.setPayload(PAYLOAD);
 512                 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.TOSCA);
 513
 514                 when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 515                 when(artifactsOperations.updateArtifactOnResource(any(ArtifactDefinition.class), any(), any(),
 516                                 any(NodeTypeEnum.class), any(String.class))).thenReturn(Either.left(artifactDefinition));
 517                 when(artifactCassandraDao.saveArtifact(any())).thenReturn(CassandraOperationStatus.OK);
 518                 when(componentsUtils.getResponseFormat(any(ActionStatus.class))).thenReturn(new ResponseFormat());
 519                 artifactBL.generateAndSaveHeatEnvArtifact(artifactDefinition, String.valueOf(PAYLOAD),
 520                                 ComponentTypeEnum.SERVICE, new Service(), RESOURCE_INSTANCE_NAME, USER, INSTANCE_ID, true, false);
 521                 verify(titanDao, times(1)).commit();
 522                 return artifactDefinition;
 523         }
 524
 525         private void verifyHeatParam(HeatParameterDefinition heatEnvParam, HeatParameterDefinition heatYamlParam) {
 526                 assertEquals(heatEnvParam.getDefaultValue(), heatYamlParam.getCurrentValue());
 527                 assertNull(heatEnvParam.getCurrentValue());
 528         }
 529
 530         private ArtifactsBusinessLogic createTestSubject() {
 531                 return new ArtifactsBusinessLogic();
 532         }
 533
 534         @Test
 535         public void testBuildJsonStringForCsarVfcArtifact() throws Exception {
 536                 ArtifactsBusinessLogic testSubject;
 537                 ArtifactDefinition artifact = new ArtifactDefinition();
 538                 String result;
 539
 540                 // default test
 541                 testSubject = createTestSubject();
 542                 result = Deencapsulation.invoke(testSubject, "buildJsonStringForCsarVfcArtifact", new Object[] { artifact });
 543         }
 544
 545         @Test
 546         public void testCheckArtifactInComponent() throws Exception {
 547                 ArtifactsBusinessLogic testSubject;
 548                 Component component = new Resource();
 549                 component.setComponentType(ComponentTypeEnum.RESOURCE);
 550                 String artifactId = "";
 551                 boolean result;
 552
 553                 // default test
 554                 testSubject = createTestSubject();
 555                 result = Deencapsulation.invoke(testSubject, "checkArtifactInComponent",
 556                                 new Object[] { component, artifactId });
 557         }
 558
 559
 560
 561         @Test
 562         public void testCheckCreateFields() throws Exception {
 563                 ArtifactsBusinessLogic testSubject;
 564                 // User user = USER;
 565                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 566                 ArtifactGroupTypeEnum type = ArtifactGroupTypeEnum.DEPLOYMENT;
 567
 568                 // default test
 569                 testSubject = createTestSubject();
 570                 Deencapsulation.invoke(testSubject, "checkCreateFields", new Object[] { user, artifactInfo, type });
 571         }
 572
 573
 574         @Test
 575         public void testComposeArtifactId() throws Exception {
 576                 ArtifactsBusinessLogic testSubject;
 577                 String resourceId = "";
 578                 String artifactId = "";
 579                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 580                 ;
 581                 String interfaceName = "";
 582                 String operationName = "";
 583                 String result;
 584
 585                 // test 1
 586                 testSubject = createTestSubject();
 587                 result = Deencapsulation.invoke(testSubject, "composeArtifactId",
 588                                 new Object[] { resourceId, artifactId, artifactInfo, interfaceName, operationName });
 589         }
 590
 591         @Test
 592         public void testConvertParentType() throws Exception {
 593                 ArtifactsBusinessLogic testSubject;
 594                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 595                 NodeTypeEnum result;
 596
 597                 // default test
 598                 testSubject = createTestSubject();
 599                 result = Deencapsulation.invoke(testSubject, "convertParentType", new Object[] { componentType });
 600         }
 601
 602         @Test
 603         public void testConvertToOperation() throws Exception {
 604                 ArtifactsBusinessLogic testSubject;
 605                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 606                 String operationName = "";
 607                 Operation result;
 608
 609                 // default test
 610                 testSubject = createTestSubject();
 611                 result = Deencapsulation.invoke(testSubject, "convertToOperation",
 612                                 new Object[] { artifactInfo, operationName });
 613         }
 614
 615         @Test
 616         public void testCreateInterfaceArtifactNameFromOperation() throws Exception {
 617                 ArtifactsBusinessLogic testSubject;
 618                 String operationName = "";
 619                 String artifactName = "";
 620                 String result;
 621
 622                 // default test
 623                 testSubject = createTestSubject();
 624                 result = Deencapsulation.invoke(testSubject, "createInterfaceArtifactNameFromOperation",
 625                                 new Object[] { operationName, artifactName });
 626         }
 627
 628         @Test
 629         public void testFetchArtifactsFromComponent() throws Exception {
 630                 ArtifactsBusinessLogic testSubject;
 631                 String artifactId = "";
 632                 Component component = createResourceObject(true);
 633                 Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 634
 635                 // default test
 636                 testSubject = createTestSubject();
 637                 Deencapsulation.invoke(testSubject, "fetchArtifactsFromComponent",
 638                                 new Object[] { artifactId, component, artifacts });
 639         }
 640
 641
 642
 643
 644
 645
 646
 647
 648         @Test
 649         public void testValidateArtifact() throws Exception {
 650         ArtifactsBusinessLogic testSubject;String componentId = "";
 651         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 652         ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
 653         ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 654         String artifactId = "";
 655         ArtifactDefinition artifactInfo = buildArtifactPayload();
 656         AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
 657
 658         Component component =  createResourceObject(true);
 659         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 660         boolean shouldLock = false;
 661         boolean inTransaction = false;
 662         ArtifactDefinition result;
 663
 664         // default test
 665         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "validateArtifact", new Object[]{componentId, componentType, operation, artifactId, artifactInfo, auditingAction, user, component, component, errorWrapper, shouldLock, inTransaction});
 666         }
 667
 668
 669         @Test
 670         public void testHandleHeatEnvDownload() throws Exception {
 671         ArtifactsBusinessLogic testSubject;String componentId = "";
 672         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 673
 674         Component component =  createResourceObject(true);
 675         ArtifactDefinition artifactInfo =  buildArtifactPayload();
 676         Either<ArtifactDefinition,ResponseFormat> validateArtifact = Either.left(artifactInfo);
 677         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 678         boolean shouldLock = false;
 679         boolean inTransaction = false;
 680
 681
 682         // default test
 683         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "handleHeatEnvDownload", new Object[]{componentId, componentType, user, component, validateArtifact, errorWrapper, shouldLock, inTransaction});
 684         }
 685
 686
 687         @Test
 688         public void testArtifactGenerationRequired() throws Exception {
 689                 ArtifactsBusinessLogic testSubject;
 690                 Component component =  createResourceObject(true);
 691                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 692                 boolean result;
 693
 694                 // default test
 695                 testSubject = createTestSubject();
 696                 result = Deencapsulation.invoke(testSubject, "artifactGenerationRequired",
 697                                 new Object[] { component, artifactInfo });
 698         }
 699
 700
 701         @Test
 702         public void testUpdateGroupForHeat() throws Exception {
 703                 ArtifactsBusinessLogic testSubject;
 704                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 705                 ArtifactDefinition artAfterUpdate = null;
 706                 Component component = createResourceObject(true);
 707                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 708                 ActionStatus result;
 709
 710                 // default test
 711                 testSubject = createTestSubject();
 712                 result = Deencapsulation.invoke(testSubject, "updateGroupForHeat", new Object[] { artifactInfo,
 713                                 artifactInfo, component,componentType});
 714         }
 715
 716
 717         @Test
 718         public void testUpdateGroupForHeat_1() throws Exception {
 719                 ArtifactsBusinessLogic testSubject;
 720                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
 721                 Component component = createResourceObject(true);
 722                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 723                 ActionStatus result;
 724
 725                 // default test
 726                 testSubject = createTestSubject();
 727                 result = Deencapsulation.invoke(testSubject, "updateGroupForHeat",
 728                                 new Object[] { artifactInfo, artifactInfo, artifactInfo,
 729                                                 artifactInfo, component,componentType});
 730         }
 731
 732
 733
 734         @Test
 735         public void testHandleAuditing() throws Exception {
 736                 ArtifactsBusinessLogic testSubject;
 737                 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
 738                 Component component =  createResourceObject(true);
 739                 String componentId = "";
 740
 741                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
 742                 String prevArtifactUuid = "";
 743                 String currentArtifactUuid = "";
 744                 ResponseFormat responseFormat = new ResponseFormat();
 745                 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 746                 String resourceInstanceName = "";
 747
 748                 // test 1
 749                 testSubject = createTestSubject();
 750                 testSubject.setComponentsUtils(MockGenerator.mockComponentUtils());
 751                 testSubject.handleAuditing(auditingActionEnum, component, componentId, user, artifactDefinition,
 752                                 prevArtifactUuid, currentArtifactUuid, responseFormat, componentTypeEnum, resourceInstanceName);
 753         }
 754
 755         @Test
 756         public void testIgnoreUnupdateableFieldsInUpdate() throws Exception {
 757                 ArtifactsBusinessLogic testSubject;
 758                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
 759                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 760                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 761                 ArtifactDefinition currentArtifactInfo = null;
 762
 763                 // default test
 764                 testSubject = createTestSubject();
 765                 Deencapsulation.invoke(testSubject, "ignoreUnupdateableFieldsInUpdate",
 766                                 new Object[] { operation, artifactInfo, artifactInfo });
 767         }
 768
 769
 770         @Test
 771         public void testFindArtifactOnParentComponent() throws Exception {
 772                 ArtifactsBusinessLogic testSubject;
 773                 Component component = createResourceObject(true);
 774                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 775                 String parentId = "";
 776                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
 777                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
 778                 String artifactId = "";
 779                 Either<ArtifactDefinition, ResponseFormat> result;
 780
 781                 // default test
 782                 testSubject = createTestSubject();
 783                 result = Deencapsulation.invoke(testSubject, "findArtifactOnParentComponent", new Object[] { component,
 784                                 componentType, parentId, operation, artifactId });
 785         }
 786
 787
 788
 789
 790         @Test
 791         public void testValidateInformationalArtifact() throws Exception {
 792                 ArtifactsBusinessLogic testSubject;
 793                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 794                 Component component = createResourceObject(true);
 795                 Either<Boolean, ResponseFormat> result;
 796
 797                 // default test
 798                 testSubject = createTestSubject();
 799                 result = Deencapsulation.invoke(testSubject, "validateInformationalArtifact",
 800                                 new Object[] { artifactInfo, component });
 801         }
 802
 803
 804
 805
 806
 807
 808         @Test
 809         public void testGetUpdatedGroups() throws Exception {
 810         ArtifactsBusinessLogic testSubject;String artifactId = "";
 811         ArtifactDefinition artifactInfo = buildArtifactPayload();
 812         List<GroupDefinition> groups = new ArrayList<>();
 813         List<GroupDataDefinition> result;
 814
 815         // test 1
 816         testSubject=createTestSubject();
 817         result=Deencapsulation.invoke(testSubject, "getUpdatedGroups", new Object[]{artifactId, artifactInfo, groups});
 818         }
 819
 820
 821         @Test
 822         public void testGetUpdatedGroupInstances() throws Exception {
 823         ArtifactsBusinessLogic testSubject;String artifactId = "";
 824         ArtifactDefinition artifactInfo = buildArtifactPayload();
 825         List<GroupDefinition> groups = new ArrayList<>();
 826         List<GroupInstance> result;
 827
 828         // default test
 829         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getUpdatedGroupInstances", new Object[]{artifactId, artifactInfo, groups});
 830         }
 831
 832
 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;String artifactId = "";
 854         Map<String,ArtifactDefinition> artifacts = new HashMap<>();
 855         ComponentInstance instance = new ComponentInstance();
 856
 857
 858         // default test
 859         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "fetchArtifactsFromInstance", new Object[]{artifactId, artifacts, instance});
 860         }
 861
 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
 881         @Test
 882         public void testFindComponentInstance() throws Exception {
 883                 ArtifactsBusinessLogic testSubject;
 884                 String componentInstanceId = "";
 885                 Component component =  createResourceObject(true);;
 886                 ComponentInstance result;
 887
 888                 // default test
 889                 testSubject = createTestSubject();
 890                 result = Deencapsulation.invoke(testSubject, "findComponentInstance",
 891                                 new Object[] { componentInstanceId, component });
 892         }
 893
 894
 895         @Test
 896         public void testValidateDeploymentArtifactConf() throws Exception {
 897         ArtifactsBusinessLogic testSubject;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", new Object[]{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
 949
 950         @Test
 951         public void testValidateHeatEnvDeploymentArtifact() throws Exception {
 952                 ArtifactsBusinessLogic testSubject;
 953                 Component component = createResourceObject(true);
 954                 String parentId = "";
 955                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
 956                 NodeTypeEnum parentType = NodeTypeEnum.AdditionalInfoParameters;
 957                 Either<Boolean, ResponseFormat> result;
 958
 959                 // default test
 960                 testSubject = createTestSubject();
 961                 result = Deencapsulation.invoke(testSubject, "validateHeatEnvDeploymentArtifact",
 962                                 new Object[] { component, parentId, artifactInfo, parentType });
 963         }
 964
 965
 966         @Test
 967         public void testFillArtifactPayloadValidation() throws Exception {
 968                 ArtifactsBusinessLogic testSubject;
 969                 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 970                 Wrapper<byte[]> payloadWrapper = new Wrapper<>();;
 971                 ArtifactDefinition artifactDefinition = buildArtifactPayload();
 972
 973                 // default test
 974                 testSubject = createTestSubject();
 975                 testSubject.fillArtifactPayloadValidation(errorWrapper, payloadWrapper, artifactDefinition);
 976         }
 977
 978
 979
 980
 981
 982
 983
 984         @Test
 985         public void testValidateValidYaml() throws Exception {
 986         ArtifactsBusinessLogic testSubject;Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 987         ArtifactDefinition artifactInfo =  buildArtifactPayload();
 988
 989
 990         // default test
 991         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "validateValidYaml", new Object[]{errorWrapper, artifactInfo});
 992         }
 993
 994
 995         @Test
 996         public void testIsValidXml() throws Exception {
 997                 ArtifactsBusinessLogic testSubject;
 998                 byte[] xmlToParse = new byte[] { ' ' };
 999                 boolean result;
1000
1001                 // default test
1002                 testSubject = createTestSubject();
1003                 result = Deencapsulation.invoke(testSubject, "isValidXml", new Object[] { xmlToParse });
1004         }
1005
1006
1007         @Test
1008         public void testValidateSingleDeploymentArtifactName() throws Exception {
1009         ArtifactsBusinessLogic testSubject;Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1010         String artifactName = "";
1011         Component component = createResourceObject(true);
1012         NodeTypeEnum parentType = null;
1013
1014
1015         // default test
1016         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "validateSingleDeploymentArtifactName", new Object[]{errorWrapper, artifactName, component, NodeTypeEnum.class});
1017         }
1018
1019
1020
1021         @Test
1022         public void testValidateHeatDeploymentArtifact() throws Exception {
1023                 ArtifactsBusinessLogic testSubject;
1024                 boolean isCreate = false;
1025                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1026                 ArtifactDefinition currentArtifact = null;
1027                 Either<Boolean, ResponseFormat> result;
1028
1029                 // default test
1030                 testSubject = createTestSubject();
1031                 result = Deencapsulation.invoke(testSubject, "validateHeatDeploymentArtifact",
1032                                 new Object[] { isCreate, artifactInfo, artifactInfo });
1033         }
1034
1035
1036         @Test
1037         public void testValidateResourceType() throws Exception {
1038         ArtifactsBusinessLogic testSubject;
1039         ResourceTypeEnum resourceType = ResourceTypeEnum.VF;
1040         ArtifactDefinition artifactInfo =  buildArtifactPayload();
1041         List<String> typeList = new ArrayList<>();
1042         Either<Boolean,ResponseFormat> result;
1043
1044         // test 1
1045         testSubject=createTestSubject();
1046         result=Deencapsulation.invoke(testSubject, "validateResourceType", new Object[]{resourceType, artifactInfo, typeList});
1047         }
1048
1049
1050         @Test
1051         public void testValidateAndConvertHeatParamers() throws Exception {
1052                 ArtifactsBusinessLogic testSubject;
1053                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1054                 String artifactType = "";
1055                 Either<ArtifactDefinition, ResponseFormat> result;
1056
1057                 // default test
1058                 testSubject = createTestSubject();
1059                 result = Deencapsulation.invoke(testSubject, "validateAndConvertHeatParamers",
1060                                 new Object[] { artifactInfo, artifactType });
1061         }
1062
1063
1064         @Test
1065         public void testGetDeploymentArtifacts() throws Exception {
1066                 ArtifactsBusinessLogic testSubject;
1067                 Component component = createResourceObject(true);
1068                 NodeTypeEnum parentType = null;
1069                 String ciId = "";
1070                 List<ArtifactDefinition> result;
1071
1072                 // default test
1073                 testSubject = createTestSubject();
1074                 result = testSubject.getDeploymentArtifacts(component, parentType, ciId);
1075         }
1076
1077
1078
1079         @Test
1080         public void testValidateFirstUpdateHasPayload() throws Exception {
1081                 ArtifactsBusinessLogic testSubject;
1082                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1083                 ArtifactDefinition currentArtifact = null;
1084                 Either<Boolean, ResponseFormat> result;
1085
1086                 // default test
1087                 testSubject = createTestSubject();
1088                 result = Deencapsulation.invoke(testSubject, "validateFirstUpdateHasPayload",
1089                                 new Object[] { artifactInfo, artifactInfo });
1090         }
1091
1092         @Test
1093         public void testValidateAndSetArtifactname() throws Exception {
1094                 ArtifactsBusinessLogic testSubject;
1095                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1096                 Either<Boolean, ResponseFormat> result;
1097
1098                 // default test
1099                 testSubject = createTestSubject();
1100                 result = Deencapsulation.invoke(testSubject, "validateAndSetArtifactname",
1101                                 new Object[] { artifactInfo });
1102         }
1103
1104         @Test
1105         public void testValidateArtifactTypeNotChanged() throws Exception {
1106                 ArtifactsBusinessLogic testSubject;
1107                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1108                 ArtifactDefinition currentArtifact = null;
1109                 Either<Boolean, ResponseFormat> result;
1110
1111                 // default test
1112                 testSubject = createTestSubject();
1113                 result = Deencapsulation.invoke(testSubject, "validateArtifactTypeNotChanged",
1114                                 new Object[] { artifactInfo, artifactInfo });
1115         }
1116
1117
1118         @Test
1119         public void testValidateOrSetArtifactGroupType() throws Exception {
1120                 ArtifactsBusinessLogic testSubject;
1121                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1122                 ArtifactDefinition currentArtifact = null;
1123                 Either<ArtifactDefinition, ResponseFormat> result;
1124
1125                 // default test
1126                 testSubject = createTestSubject();
1127                 result = Deencapsulation.invoke(testSubject, "validateOrSetArtifactGroupType",
1128                                 new Object[] { artifactInfo, artifactInfo });
1129         }
1130
1131
1132         @Test
1133         public void testCheckAndSetUnUpdatableFields() throws Exception {
1134                 ArtifactsBusinessLogic testSubject;
1135
1136                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1137                 ArtifactDefinition currentArtifact = null;
1138                 ArtifactGroupTypeEnum type = null;
1139
1140                 // test 1
1141                 testSubject = createTestSubject();
1142                 type = null;
1143                 Deencapsulation.invoke(testSubject, "checkAndSetUnUpdatableFields", new Object[] { user,
1144                                 artifactInfo, artifactInfo, ArtifactGroupTypeEnum.class });
1145         }
1146
1147
1148         @Test
1149         public void testCheckAndSetUnupdatableHeatParams() throws Exception {
1150         ArtifactsBusinessLogic testSubject;
1151         List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1152         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1153
1154
1155         // default test
1156         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "checkAndSetUnupdatableHeatParams", new Object[]{heatParameters, currentParameters});
1157         }
1158
1159
1160         @Test
1161         public void testGetMapOfParameters() throws Exception {
1162         ArtifactsBusinessLogic testSubject;
1163         List<HeatParameterDefinition> currentParameters = new ArrayList<>();
1164         Map<String,HeatParameterDefinition> result;
1165
1166         // default test
1167         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getMapOfParameters", new Object[]{currentParameters});
1168         }
1169
1170
1171         @Test
1172         public void testGivenValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1173                 final byte[] payload = "validYaml: yes".getBytes();
1174                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1175
1176                 final boolean isArtifactMetadataUpdate = false;
1177                 ArtifactsBusinessLogic testSubject = new ArtifactsBusinessLogic();
1178
1179                 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1180                                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1181                 assertArrayEquals(payload, result.left().value());
1182         }
1183
1184         @Test
1185         public void testGivenInValidVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1186                 final int expectedStatus = 100;
1187                 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_YAML), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1188                 final byte[] payload = "invalidYaml".getBytes();
1189                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1190
1191                 final boolean isArtifactMetadataUpdate = false;
1192                 ArtifactsBusinessLogic testSubject = new ArtifactsBusinessLogic();
1193                 testSubject.setComponentsUtils(componentsUtils);
1194
1195                 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1196                                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1197
1198                 int status = result.right().value().getStatus();
1199                 assertEquals(expectedStatus, status);
1200         }
1201
1202         @Test
1203         public void testGivenEmptyVesEventsArtifactPayload_WhenHandlePayload_ThenResultIsMissingData() {
1204                 final int expectedStatus = 101;
1205                 when(componentsUtils.getResponseFormat(eq(ActionStatus.MISSING_DATA), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1206                 final byte[] payload = "".getBytes();
1207                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "ves_events_file.yaml", ArtifactTypeEnum.VES_EVENTS);
1208
1209                 final boolean isArtifactMetadataUpdate = false;
1210                 ArtifactsBusinessLogic testSubject = new ArtifactsBusinessLogic();
1211                 testSubject.setComponentsUtils(componentsUtils);
1212
1213                 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1214                                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1215
1216                 int status = result.right().value().getStatus();
1217                 assertEquals(expectedStatus, status);
1218         }
1219
1220         @Test
1221         public void testGivenValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsDecodedPayload() {
1222                 final byte[] payload = "heat_template_version: 1.0".getBytes();
1223                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1224
1225                 final boolean isArtifactMetadataUpdate = false;
1226                 ArtifactsBusinessLogic testSubject = new ArtifactsBusinessLogic();
1227
1228                 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1229                                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1230                 assertArrayEquals(payload, result.left().value());
1231         }
1232
1233         @Test
1234         public void testGivenInValidHeatArtifactPayload_WhenHandlePayload_ThenResultIsInvalidYaml() {
1235                 final int expectedStatus = 1000;
1236                 when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT), any(String.class))).thenReturn(new ResponseFormat(expectedStatus));
1237                 final byte[] payload = "validYaml: butNoHeatTemplateVersion".getBytes();
1238                 ArtifactDefinition artifactInfo = createArtifactInfo(payload, "heat_template.yaml", ArtifactTypeEnum.HEAT);
1239
1240                 final boolean isArtifactMetadataUpdate = false;
1241                 ArtifactsBusinessLogic testSubject = new ArtifactsBusinessLogic();
1242                 testSubject.setComponentsUtils(componentsUtils);
1243
1244                 Either<byte[], ResponseFormat> result = Deencapsulation.invoke(testSubject, "handlePayload",
1245                                 new Object[] { artifactInfo, isArtifactMetadataUpdate });
1246
1247                 int status = result.right().value().getStatus();
1248                 assertEquals(expectedStatus, status);
1249         }
1250
1251         private ArtifactDefinition createArtifactInfo(byte[] payload, String artifactName, ArtifactTypeEnum artifactType) {
1252                 ArtifactDefinition artifactInfo = new ArtifactDefinition();
1253                 artifactInfo.setArtifactName(artifactName);
1254                 artifactInfo.setArtifactType(artifactType.getType());
1255                 artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1256                 artifactInfo.setPayload(Base64.encodeBase64(payload));
1257                 return artifactInfo;
1258         }
1259
1260
1261         @Test
1262         public void testValidateUserRole() throws Exception {
1263                 ArtifactsBusinessLogic testSubject;
1264
1265                 AuditingActionEnum auditingAction = AuditingActionEnum.ADD_CATEGORY;
1266                 String componentId = "";
1267                 String artifactId = "";
1268                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1269                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
1270                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1271                 Either<Boolean, ResponseFormat> result;
1272
1273                 // default test
1274                 testSubject = createTestSubject();
1275                 result = Deencapsulation.invoke(testSubject, "validateUserRole",
1276                                 new Object[] { user, auditingAction, componentId, artifactId, componentType,
1277                                                 operation });
1278         }
1279
1280         @Test
1281         public void testDetectAuditingType() throws Exception {
1282                 ArtifactsBusinessLogic testSubject;
1283                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
1284                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1285                 String origMd5 = "";
1286                 AuditingActionEnum result;
1287
1288                 // default test
1289                 testSubject = createTestSubject();
1290                 result = Deencapsulation.invoke(testSubject, "detectAuditingType",
1291                                 new Object[] { operation, origMd5 });
1292         }
1293
1294
1295
1296
1297         @Test
1298         public void testCreateEsArtifactData() throws Exception {
1299                 ArtifactsBusinessLogic testSubject;
1300                 ArtifactDataDefinition artifactInfo = buildArtifactPayload();;;
1301                 byte[] artifactPayload = new byte[] { ' ' };
1302                 ESArtifactData result;
1303
1304                 // default test
1305                 testSubject = createTestSubject();
1306                 result = testSubject.createEsArtifactData(artifactInfo, artifactPayload);
1307         }
1308
1309
1310
1311
1312
1313         @Test
1314         public void testIsArtifactMetadataUpdate() throws Exception {
1315                 ArtifactsBusinessLogic testSubject;
1316                 AuditingActionEnum auditingActionEnum = AuditingActionEnum.ACTIVATE_SERVICE_BY_API;
1317                 boolean result;
1318
1319                 // default test
1320                 testSubject = createTestSubject();
1321                 result = Deencapsulation.invoke(testSubject, "isArtifactMetadataUpdate",
1322                                 new Object[] { auditingActionEnum });
1323         }
1324
1325
1326         @Test
1327         public void testIsDeploymentArtifact() throws Exception {
1328                 ArtifactsBusinessLogic testSubject;
1329                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1330                 boolean result;
1331
1332                 // default test
1333                 testSubject = createTestSubject();
1334                 result = Deencapsulation.invoke(testSubject, "isDeploymentArtifact", new Object[] { artifactInfo });
1335         }
1336
1337
1338
1339
1340
1341         @Test
1342         public void testSetArtifactPlaceholderCommonFields() throws Exception {
1343                 ArtifactsBusinessLogic testSubject;
1344                 String resourceId = "";
1345
1346                 ArtifactDefinition artifactInfo =  buildArtifactPayload();
1347
1348                 // test 1
1349                 testSubject = createTestSubject();
1350                 Deencapsulation.invoke(testSubject, "setArtifactPlaceholderCommonFields",
1351                                 new Object[] { resourceId, user, artifactInfo });
1352
1353         }
1354
1355
1356         @Test
1357         public void testCreateEsHeatEnvArtifactDataFromString() throws Exception {
1358                 ArtifactsBusinessLogic testSubject;
1359                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
1360                 String payloadStr = "";
1361                 Either<ESArtifactData, ResponseFormat> result;
1362
1363                 // default test
1364                 testSubject = createTestSubject();
1365                 result = Deencapsulation.invoke(testSubject, "createEsHeatEnvArtifactDataFromString",
1366                                 new Object[] { artifactDefinition, payloadStr });
1367         }
1368
1369
1370
1371
1372
1373
1374
1375
1376         @Test
1377         public void testUpdateArtifactOnGroupInstance() throws Exception {
1378                 ArtifactsBusinessLogic testSubject;
1379                 ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
1380                 Component component =  createResourceObject(true);
1381                 String instanceId = "";
1382                 String prevUUID = "";
1383                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1384                 Either<ArtifactDefinition, ResponseFormat> result;
1385
1386                 // test 1
1387                 testSubject = createTestSubject();
1388                 prevUUID = "";
1389                 result = Deencapsulation.invoke(testSubject, "updateArtifactOnGroupInstance",
1390                                 new Object[] {componentType, component, instanceId, prevUUID, artifactInfo,
1391                                                 artifactInfo });
1392
1393         }
1394
1395
1396         @Test
1397         public void testGenerateHeatEnvPayload() throws Exception {
1398                 ArtifactsBusinessLogic testSubject;
1399                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;;
1400                 String result;
1401
1402                 // default test
1403                 testSubject = createTestSubject();
1404                 result = Deencapsulation.invoke(testSubject, "generateHeatEnvPayload",
1405                                 new Object[] { artifactDefinition });
1406         }
1407
1408
1409
1410
1411
1412
1413         @Test
1414         public void testBuildJsonForUpdateArtifact() throws Exception {
1415                 ArtifactsBusinessLogic testSubject;
1416                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1417                 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1418                 List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1419                 Map<String, Object> result;
1420
1421                 // default test
1422                 testSubject = createTestSubject();
1423                 result = testSubject.buildJsonForUpdateArtifact(artifactInfo, artifactGroupType, updatedRequiredArtifacts);
1424         }
1425
1426
1427         @Test
1428         public void testBuildJsonForUpdateArtifact_1() throws Exception {
1429                 ArtifactsBusinessLogic testSubject;
1430                 String artifactId = "";
1431                 String artifactName = "";
1432                 String artifactType = "";
1433                 ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.DEPLOYMENT;
1434                 String label = "";
1435                 String displayName = "";
1436                 String description = "";
1437                 byte[] artifactContent = new byte[] { ' ' };
1438                 List<ArtifactTemplateInfo> updatedRequiredArtifacts = new ArrayList<>();
1439                 List<HeatParameterDefinition> heatParameters = new ArrayList<>();
1440                 Map<String, Object> result;
1441
1442                 // test 1
1443                 testSubject = createTestSubject();
1444                 artifactId = "";
1445                 result = testSubject.buildJsonForUpdateArtifact(artifactId, artifactName, artifactType, artifactGroupType,
1446                                 label, displayName, description, artifactContent, updatedRequiredArtifacts, heatParameters);
1447         }
1448
1449
1450
1451
1452
1453
1454         @Test
1455         public void testReplaceCurrHeatValueWithUpdatedValue() throws Exception {
1456         ArtifactsBusinessLogic testSubject;
1457         List<HeatParameterDefinition> currentHeatEnvParams = new ArrayList<>();
1458         List<HeatParameterDefinition> updatedHeatEnvParams = new ArrayList<>();
1459
1460
1461         // default test
1462         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "replaceCurrHeatValueWithUpdatedValue", new Object[]{currentHeatEnvParams, updatedHeatEnvParams});
1463         }
1464
1465
1466
1467         @Test
1468         public void testExtractArtifactDefinition() throws Exception {
1469                 ArtifactsBusinessLogic testSubject;
1470                 ArtifactDefinition artifactDefinition = buildArtifactPayload();;
1471                 Either<ArtifactDefinition, Operation> eitherArtifact = Either.left(artifactDefinition);
1472                 ArtifactDefinition result;
1473
1474                 // default test
1475                 testSubject = createTestSubject();
1476                 result = testSubject.extractArtifactDefinition(eitherArtifact);
1477         }
1478
1479
1480
1481
1482         @Test
1483         public void testSetHeatCurrentValuesOnHeatEnvDefaultValues() throws Exception {
1484                 ArtifactsBusinessLogic testSubject;
1485                 ArtifactDefinition artifact = null;
1486                 ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1487
1488                 // default test
1489                 testSubject = createTestSubject();
1490                 Deencapsulation.invoke(testSubject, "setHeatCurrentValuesOnHeatEnvDefaultValues",
1491                                 new Object[] { artifactInfo, artifactInfo });
1492         }
1493
1494
1495         @Test
1496         public void testBuildHeatEnvFileName() throws Exception {
1497         ArtifactsBusinessLogic testSubject;
1498         ArtifactDefinition heatArtifact = null;
1499         ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1500         Map<String,Object> placeHolderData = new HashMap<>();
1501
1502
1503         // default test
1504         testSubject=createTestSubject();Deencapsulation.invoke(testSubject, "buildHeatEnvFileName", new Object[]{artifactInfo, artifactInfo, placeHolderData});
1505         }
1506
1507
1508         @Test
1509         public void testHandleEnvArtifactVersion() throws Exception {
1510         ArtifactsBusinessLogic testSubject;
1511         ArtifactDefinition artifactInfo = buildArtifactPayload();;;
1512         Map<String,String> existingEnvVersions = new HashMap<>();
1513
1514
1515         // test 1
1516         testSubject=createTestSubject();
1517         Deencapsulation.invoke(testSubject, "handleEnvArtifactVersion", new Object[]{artifactInfo, existingEnvVersions});
1518         }
1519
1520
1521         @Test
1522         public void testHandleArtifactsRequestForInnerVfcComponent() throws Exception {
1523                 ArtifactsBusinessLogic testSubject;
1524                 List<ArtifactDefinition> artifactsToHandle = new ArrayList<>();;
1525                 Resource component = createResourceObject(true);;
1526
1527                 List<ArtifactDefinition> vfcsNewCreatedArtifacts = new ArrayList<>();;
1528                 ArtifactsBusinessLogic arb = new ArtifactsBusinessLogic();
1529                 ArtifactOperationInfo operation = arb.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE);
1530                 boolean shouldLock = false;
1531                 boolean inTransaction = false;
1532                 Either<List<ArtifactDefinition>, ResponseFormat> result;
1533
1534                 // default test
1535                 testSubject = createTestSubject();
1536                 result = testSubject.handleArtifactsRequestForInnerVfcComponent(artifactsToHandle, component, user,
1537                                 vfcsNewCreatedArtifacts, operation, shouldLock, inTransaction);
1538         }
1539
1540
1541         @Test
1542         public void testSetNodeTemplateOperation() throws Exception {
1543                 ArtifactsBusinessLogic testSubject;
1544                 NodeTemplateOperation nodeTemplateOperation = null;
1545
1546                 // default test
1547                 testSubject = createTestSubject();
1548                 Deencapsulation.invoke(testSubject, "setNodeTemplateOperation", new Object[] { NodeTemplateOperation.class });
1549         }
1550 }