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