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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.components.impl;
  24
  25 import fj.data.Either;
  26 import org.apache.commons.lang3.tuple.ImmutablePair;
  27 import org.junit.Assert;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.mockito.InjectMocks;
  31 import org.mockito.Mockito;
  32 import org.mockito.MockitoAnnotations;
  33 import org.openecomp.sdc.ElementOperationMock;
  34 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  35 import org.openecomp.sdc.be.components.ArtifactsResolver;
  36 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
  37 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  38 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  39 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
  40 import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils;
  41 import org.openecomp.sdc.be.components.utils.ComponentBusinessLogicMock;
  42 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  43 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
  44 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
  45 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
  46 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  47 import org.openecomp.sdc.be.model.operations.StorageException;
  48 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
  49 import org.openecomp.sdc.be.components.csar.CsarInfo;
  50 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  51 import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic;
  52 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  53 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  54 import org.openecomp.sdc.be.components.validation.UserValidations;
  55 import org.openecomp.sdc.be.config.ConfigurationManager;
  56 import org.openecomp.sdc.be.dao.api.ActionStatus;
  57 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  58 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  59 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  60 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  61 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  62 import org.openecomp.sdc.be.impl.ComponentsUtils;
  63 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
  64 import org.openecomp.sdc.be.model.ArtifactDefinition;
  65 import org.openecomp.sdc.be.model.Component;
  66 import org.openecomp.sdc.be.model.DataTypeDefinition;
  67 import org.openecomp.sdc.be.model.InputDefinition;
  68 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
  69 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  70 import org.openecomp.sdc.be.model.PropertyDefinition;
  71 import org.openecomp.sdc.be.model.Resource;
  72 import org.openecomp.sdc.be.model.User;
  73 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  74 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
  75 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation;
  76 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation;
  77 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  78 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
  79 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  80 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  81 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  82 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  83 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  84 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  85 import org.openecomp.sdc.be.model.operations.impl.CsarOperation;
  86 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  87 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  88 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  89 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  90 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  91 import org.openecomp.sdc.be.tosca.CsarUtils;
  92 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
  93 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
  94 import org.openecomp.sdc.be.user.IUserBusinessLogic;
  95 import org.openecomp.sdc.be.user.Role;
  96 import org.openecomp.sdc.be.user.UserBusinessLogic;
  97 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  98 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  99 import org.openecomp.sdc.common.api.ConfigurationSource;
 100 import org.openecomp.sdc.common.api.Constants;
 101 import org.openecomp.sdc.common.impl.ExternalConfiguration;
 102 import org.openecomp.sdc.common.impl.FSConfigurationSource;
 103 import org.openecomp.sdc.common.util.GeneralUtility;
 104 import org.openecomp.sdc.common.util.ValidationUtils;
 105 import org.openecomp.sdc.exception.ResponseFormat;
 106 import org.slf4j.Logger;
 107 import org.slf4j.LoggerFactory;
 108 import org.springframework.web.context.WebApplicationContext;
 109
 110 import javax.servlet.ServletContext;
 111 import java.io.IOException;
 112 import java.lang.reflect.Method;
 113 import java.util.ArrayList;
 114 import java.util.EnumMap;
 115 import java.util.HashMap;
 116 import java.util.List;
 117 import java.util.Map;
 118 import java.util.stream.Collectors;
 119 import java.util.stream.Stream;
 120
 121 import static org.junit.Assert.assertEquals;
 122 import static org.junit.Assert.assertFalse;
 123 import static org.junit.Assert.assertNotNull;
 124 import static org.junit.Assert.assertTrue;
 125 import static org.mockito.ArgumentMatchers.any;
 126 import static org.mockito.ArgumentMatchers.anyString;
 127 import static org.mockito.ArgumentMatchers.eq;
 128 import static org.mockito.Mockito.when;
 129
 130 import static org.assertj.core.api.Java6Assertions.assertThat;
 131 import static org.junit.Assert.assertNotEquals;
 132 import static org.mockito.Mockito.times;
 133
 134 public class ResourceBusinessLogicTest extends ComponentBusinessLogicMock {
 135
 136     private static final Logger log = LoggerFactory.getLogger(ResourceBusinessLogicTest.class);
 137     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 138     private static final String RESOURCE_SUBCATEGORY = "Router";
 139
 140     private static final String UPDATED_SUBCATEGORY = "Gateway";
 141
 142     private String resourceId = "resourceId1";
 143     private String operationId = "uniqueId1";
 144     Resource resourceUpdate;
 145
 146     private static final String RESOURCE_NAME = "My-Resource_Name with   space";
 147     private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
 148     private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF";
 149     private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR";
 150     private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF";
 151
 152     final ServletContext servletContext = Mockito.mock(ServletContext.class);
 153     IElementOperation mockElementDao = new ElementOperationMock();
 154     JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
 155     UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
 156     ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 157     NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class);
 158     NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class);
 159     TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
 160     final LifecycleBusinessLogic lifecycleBl = Mockito.mock(LifecycleBusinessLogic.class);
 161     final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class);
 162     final PropertyOperation propertyOperation = Mockito.mock(PropertyOperation.class);
 163     final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
 164     WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
 165     UserValidations userValidations = Mockito.mock(UserValidations.class);
 166     WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
 167     IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class);
 168     ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class);
 169
 170     CsarUtils csarUtils = Mockito.mock(CsarUtils.class);
 171     IUserBusinessLogic userBusinessLogic = Mockito.mock(IUserBusinessLogic.class);
 172     IGroupOperation groupOperation = Mockito.mock(IGroupOperation.class);
 173     IGroupInstanceOperation groupInstanceOperation = Mockito.mock(IGroupInstanceOperation.class);
 174     IGroupTypeOperation groupTypeOperation = Mockito.mock(IGroupTypeOperation.class);
 175     GroupBusinessLogic groupBusinessLogic = Mockito.mock(GroupBusinessLogic.class);
 176     InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class);
 177     ArtifactsOperations artifactToscaOperation = Mockito.mock(ArtifactsOperations.class);
 178     ArtifactsResolver artifactsResolver = Mockito.mock(ArtifactsResolver.class);
 179     InterfaceLifecycleOperation interfaceLifecycleTypeOperation = Mockito.mock(InterfaceLifecycleOperation.class);
 180     ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
 181     ResourceImportManager resourceImportManager = Mockito.mock(ResourceImportManager.class);
 182     InputsBusinessLogic inputsBusinessLogic = Mockito.mock(InputsBusinessLogic.class);
 183     CompositionBusinessLogic compositionBusinessLogic = Mockito.mock(CompositionBusinessLogic.class);
 184     ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic = Mockito.mock(ResourceDataMergeBusinessLogic.class);
 185     CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic = Mockito.mock(CsarArtifactsAndGroupsBusinessLogic.class);
 186     MergeInstanceUtils mergeInstanceUtils = Mockito.mock(MergeInstanceUtils.class);
 187     UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class);
 188
 189     ResponseFormatManager responseManager = null;
 190     GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
 191     User user = null;
 192     Resource resourceResponse = null;
 193     Resource genericVF = null;
 194     Resource genericCR = null;
 195     Resource genericVFC = null;
 196     Resource genericPNF = null;
 197     ComponentsUtils componentsUtils;
 198     ArtifactsBusinessLogic artifactManager;
 199     CsarOperation csarOperation = Mockito.mock(CsarOperation.class);
 200     @InjectMocks
 201     CsarBusinessLogic csarBusinessLogic;
 202     Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 203     private GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class);
 204     List<Resource> reslist;
 205     ResourceBusinessLogic bl;
 206
 207     public ResourceBusinessLogicTest() {
 208     }
 209
 210     @Before
 211     public void setup() {
 212         MockitoAnnotations.initMocks(this);
 213         Mockito.reset(propertyOperation);
 214
 215         ExternalConfiguration.setAppName("catalog-be");
 216
 217         // init Configuration
 218         String appConfigDir = "src/test/resources/config/catalog-be";
 219         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 220         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 221         componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 222
 223         ToscaExportHandler toscaExportHandler = Mockito.mock(ToscaExportHandler.class);
 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         Either<User, ActionStatus> eitherGetUser = Either.left(user);
 233         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
 234         when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).thenReturn(user);
 235         when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 236         // Servlet Context attributes
 237         when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
 238         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
 239         when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
 240         when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
 241
 242         Either<Integer, StorageOperationStatus> eitherCountRoot = Either.left(1);
 243         Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true);
 244         when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherFalse);
 245
 246
 247         Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
 248         when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
 249
 250         Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
 251         when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
 252         /*when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.VF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
 253         when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.PNF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
 254         when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);*/
 255         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
 256         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 257
 258         Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false);
 259         when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists);
 260         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 261         when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
 262
 263         // createResource
 264         resourceResponse = createResourceObject(true);
 265         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
 266         Either<Integer, StorageOperationStatus> eitherValidate = Either.left(null);
 267         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 268         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
 269         when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
 270         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 271
 272         // BL object
 273         artifactManager = new ArtifactsBusinessLogic(artifactCassandraDao, toscaExportHandler, csarUtils, lifecycleBl, userBusinessLogic,
 274             artifactsResolver, mockElementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
 275             interfaceLifecycleTypeOperation, artifactToscaOperation);
 276
 277         bl = new ResourceBusinessLogic(mockElementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic,
 278             interfaceOperation, interfaceLifecycleTypeOperation, artifactManager, componentInstanceBusinessLogic,
 279             resourceImportManager, inputsBusinessLogic, compositionBusinessLogic, resourceDataMergeBusinessLogic,
 280             csarArtifactsAndGroupsBusinessLogic, mergeInstanceUtils, uiComponentDataConverter, csarBusinessLogic,
 281             artifactToscaOperation);
 282
 283         artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
 284         bl.setUserAdmin(mockUserAdmin);
 285         bl.setCapabilityTypeOperation(capabilityTypeOperation);
 286         bl.setComponentsUtils(componentsUtils);
 287         bl.setLifecycleManager(lifecycleBl);
 288         bl.setGraphLockOperation(graphLockOperation);
 289         bl.setPropertyOperation(propertyOperation);
 290         bl.setJanusGraphDao(mockJanusGraphDao);
 291         bl.setApplicationDataTypeCache(applicationDataTypeCache);
 292         bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic);
 293         toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation);
 294         toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation);
 295         bl.setToscaOperationFacade(toscaOperationFacade);
 296         bl.setUserValidations(userValidations);
 297         bl.setInterfaceTypeOperation(interfaceTypeOperation);
 298
 299         csarBusinessLogic.setCsarOperation(csarOperation);
 300         Resource resourceCsar = createResourceObjectCsar(true);
 301         setCanWorkOnResource(resourceCsar);
 302         Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar);
 303         when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes);
 304         responseManager = ResponseFormatManager.getInstance();
 305
 306         reslist = new ArrayList<Resource>();
 307         reslist.add(resourceResponse);
 308         reslist.add(genericVF);
 309         reslist.add(genericCR);
 310         reslist.add(genericVFC);
 311         reslist.add(genericPNF);
 312         Either<List<Resource>, StorageOperationStatus> returneval= Either.left(reslist);
 313         when(toscaOperationFacade.getAllCertifiedResources(true, true)).thenReturn(returneval);
 314         when(toscaOperationFacade.validateComponentNameUniqueness("Resource", ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(Either.left(true));
 315         Either<List<Resource>, StorageOperationStatus> returnevalexception= Either.right(StorageOperationStatus.BAD_REQUEST);
 316         when(toscaOperationFacade.getAllCertifiedResources(false, false)).thenReturn(returnevalexception);
 317
 318     }
 319
 320     private Resource createResourceObject(boolean afterCreate) {
 321         Resource resource = new Resource();
 322         resource.setName(RESOURCE_NAME);
 323         resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
 324         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 325         resource.setDescription("My short description");
 326         List<String> tgs = new ArrayList<>();
 327         tgs.add("test");
 328         tgs.add(resource.getName());
 329         resource.setTags(tgs);
 330         List<String> template = new ArrayList<>();
 331         template.add("Root");
 332         resource.setDerivedFrom(template);
 333         resource.setVendorName("Motorola");
 334         resource.setVendorRelease("1.0.0");
 335         resource.setContactId("ya5467");
 336         resource.setIcon("MyIcon");
 337
 338         if (afterCreate) {
 339             resource.setName(resource.getName());
 340             resource.setVersion("0.1");
 341             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 342             resource.setCreatorUserId(user.getUserId());
 343             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 344             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 345         }
 346         return resource;
 347     }
 348
 349     private Resource createResourceObjectCsar(boolean afterCreate) {
 350         Resource resource = new Resource();
 351         resource.setName(RESOURCE_NAME);
 352         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
 353         resource.setDescription("My short description");
 354         List<String> tgs = new ArrayList<>();
 355         tgs.add("test");
 356         tgs.add(resource.getName());
 357         resource.setTags(tgs);
 358         List<String> template = new ArrayList<>();
 359         template.add("Root");
 360         resource.setDerivedFrom(template);
 361         resource.setVendorName("Motorola");
 362         resource.setVendorRelease("1.0.0");
 363         resource.setResourceVendorModelNumber("");
 364         resource.setContactId("ya5467");
 365         resource.setIcon("MyIcon");
 366         resource.setCsarUUID("valid_vf.csar");
 367         resource.setCsarVersion("1");
 368
 369         if (afterCreate) {
 370             resource.setName(resource.getName());
 371             resource.setVersion("0.1");
 372
 373             resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 374             resource.setCreatorUserId(user.getUserId());
 375             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 376             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 377         }
 378         return resource;
 379     }
 380
 381     private Resource setCanWorkOnResource(Resource resource) {
 382         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 383         resource.setLastUpdaterUserId(user.getUserId());
 384         return resource;
 385     }
 386
 387     @Test
 388     public void testHappyScenario() {
 389         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 390         Resource resource = createResourceObject(false);
 391         Resource createdResource = null;
 392         try{
 393             createdResource= bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 394             assertThat(createResourceObject(true)).isEqualTo(createdResource);
 395         } catch(ByResponseFormatComponentException e){
 396             assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
 397         }
 398     }
 399
 400     @Test
 401     public void testUpdateHappyScenario() {
 402         Resource resource = createResourceObjectCsar(true);
 403         setCanWorkOnResource(resource);
 404         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 405         Either<Resource, StorageOperationStatus> resourceLinkedToCsarRes = Either.left(resource);
 406         when(toscaOperationFacade.getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, resource.getCsarUUID(), resource.getSystemName())).thenReturn(resourceLinkedToCsarRes);
 407         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
 408         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 409         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
 410         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
 411         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
 412         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
 413         Resource createdResource = null;
 414         try{
 415             createdResource= bl.validateAndUpdateResourceFromCsar(resource, user, null, null, resource.getUniqueId());
 416             assertThat(resource.getUniqueId()).isEqualTo(createdResource.getUniqueId());
 417         } catch(ByResponseFormatComponentException e){
 418             assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
 419         }
 420     }
 421
 422
 423     @Test
 424     public void testFailedResourceValidations() {
 425         testResourceNameExist();
 426         testResourceNameEmpty();
 427         // testResourceNameExceedsLimit();
 428         testResourceNameWrongFormat();
 429         testResourceDescExceedsLimitCreate();
 430         testResourceDescNotEnglish();
 431         testResourceDescriptionEmpty();
 432         testResourceDescriptionMissing();
 433         testResourceIconMissing();
 434         testResourceIconInvalid();
 435         testResourceIconExceedsLimit();
 436         testResourceTagNotExist();
 437         testResourceTagEmpty();
 438         testTagsExceedsLimitCreate();
 439         testTagsNoServiceName();
 440         testInvalidTag();
 441
 442         testContactIdTooLong();
 443         testContactIdWrongFormatCreate();
 444         testResourceContactIdEmpty();
 445         testResourceContactIdMissing();
 446         testVendorNameExceedsLimit();
 447         testVendorNameWrongFormatCreate();
 448         testVendorReleaseWrongFormat();
 449         testVendorReleaseExceedsLimitCreate();
 450         testResourceVendorModelNumberExceedsLimit();
 451         testResourceVendorNameMissing();
 452         testResourceVendorReleaseMissing();
 453         testResourceCategoryExist();
 454         testResourceBadCategoryCreate();
 455         testHappyScenarioCostLicenseType();
 456         testCostWrongFormatCreate();
 457         testLicenseTypeWrongFormatCreate();
 458         testResourceTemplateNotExist();
 459         testResourceTemplateEmpty();
 460         testResourceTemplateInvalid();
 461     }
 462
 463     private void testResourceNameExist() {
 464         String resourceName = "alreadyExists";
 465         Resource resourceExist = createResourceObject(false);
 466         resourceExist.setName(resourceName);
 467         resourceExist.getTags().add(resourceName);
 468         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 469         try {
 470             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 471         } catch (ByResponseFormatComponentException e) {
 472             assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resourceName);
 473         }
 474     }
 475
 476     private void testResourceNameEmpty() {
 477         Resource resourceExist = createResourceObject(false);
 478         resourceExist.setName(null);
 479
 480         try {
 481             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 482         } catch (ByActionStatusComponentException e) {
 483             assertComponentException(e, ActionStatus.MISSING_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
 484         }
 485     }
 486
 487     private void testResourceNameExceedsLimit() {
 488         Resource resourceExccedsNameLimit = createResourceObject(false);
 489         // 51 chars, the limit is 50
 490         String tooLongResourceName = "zCRCAWjqte0DtgcAAMmcJcXeNubeX1p1vOZNTShAHOYNAHvV3iK";
 491         resourceExccedsNameLimit.setName(tooLongResourceName);
 492
 493         try {
 494             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 495         } catch (ByActionStatusComponentException e) {
 496             assertComponentException(e, ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
 497         }
 498     }
 499
 500     private void testResourceNameWrongFormat() {
 501         Resource resource = createResourceObject(false);
 502         // contains :
 503         String nameWrongFormat = "ljg?fd";
 504         resource.setName(nameWrongFormat);
 505
 506         try {
 507             bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 508         } catch (ByActionStatusComponentException e) {
 509             assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
 510         }
 511     }
 512
 513     // Resource name - end
 514     // Resource description - start
 515     private void testResourceDescExceedsLimitCreate() {
 516         Resource resourceExccedsDescLimit = createResourceObject(false);
 517         // 1025 chars, the limit is 1024
 518         String tooLongResourceDesc = "1GUODojQ0sGzKR4NP7e5j82ADQ3KHTVOaezL95qcbuaqDtjZhAQGQ3iFwKAy580K4WiiXs3u3zq7RzXcSASl5fm0RsWtCMOIDP"
 519                 + "AOf9Tf2xtXxPCuCIMCR5wOGnNTaFxgnJEHAGxilBhZDgeMNHmCN1rMK5B5IRJOnZxcpcL1NeG3APTCIMP1lNAxngYulDm9heFSBc8TfXAADq7703AvkJT0QPpGq2z2P"
 520                 + "tlikcAnIjmWgfC5Tm7UH462BAlTyHg4ExnPPL4AO8c92VrD7kZSgSqiy73cN3gLT8uigkKrUgXQFGVUFrXVyyQXYtVM6bLBeuCGQf4C2j8lkNg6M0J3PC0PzMRoinOxk"
 521                 + "Ae2teeCtVcIj4A1KQo3210j8q2v7qQU69Mabsa6DT9FgE4rcrbiFWrg0Zto4SXWD3o1eJA9o29lTg6kxtklH3TuZTmpi5KVp1NFhS1RpnqF83tzv4mZLKsx7Zh1fEgYvRFwx1"
 522                 + "ar3RolyDfNoZiGBGTMsZzz7RPFBf2hTnLmNqVGQnHKhhGj0Y5s8t2cbqbO2nmHiJb9uaUVrCGypgbAcJL3KPOBfAVW8PcpmNj4yVjI3L4x5zHjmGZbp9vKshEQODcrmcgsYAoKqe"
 523                 + "uu5u7jk8XVxEfQ0m5qL8UOErXPlJovSmKUmP5B5T0w299zIWDYCzSoNasHpHjOMDLAiDDeHbozUOn9t3Qou00e9POq4RMM0VnIx1H38nJoJZz2XH8CI5YMQe7oTagaxgQTF2aa0qaq2"
 524                 + "V6nJsfRGRklGjNhFFYP2cS4Xv2IJO9DSX6LTXOmENrGVJJvMOZcvnBaZPfoAHN0LU4i1SoepLzulIxnZBfkUWFJgZ5wQ0Bco2GC1HMqzW21rwy4XHRxXpXbmW8LVyoA1KbnmVmROycU4"
 525                 + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
 526
 527         resourceExccedsDescLimit.setDescription(tooLongResourceDesc);
 528         try {
 529             bl.createResource(resourceExccedsDescLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 530         } catch (ByActionStatusComponentException e) {
 531             assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH);
 532         }
 533     }
 534
 535     private void testResourceDescNotEnglish() {
 536         Resource notEnglish = createResourceObject(false);
 537         // Not english
 538         String notEnglishDesc = "\uC2B5";
 539         notEnglish.setDescription(notEnglishDesc);
 540
 541         try {
 542             bl.createResource(notEnglish, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 543         } catch (ByActionStatusComponentException e) {
 544             assertComponentException(e, ActionStatus.COMPONENT_INVALID_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
 545         }
 546     }
 547
 548     private void testResourceDescriptionEmpty() {
 549         Resource resourceExist = createResourceObject(false);
 550         resourceExist.setDescription("");
 551
 552         try {
 553             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 554         } catch (ByActionStatusComponentException e) {
 555             assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
 556         }
 557     }
 558
 559     private void testResourceDescriptionMissing() {
 560         Resource resourceExist = createResourceObject(false);
 561         resourceExist.setDescription(null);
 562
 563         try {
 564             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 565         } catch (ByActionStatusComponentException e) {
 566             assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, ComponentTypeEnum.RESOURCE.getValue());
 567         }
 568     }
 569     // Resource description - end
 570     // Resource icon start
 571
 572     private void testResourceIconMissing() {
 573         Resource resourceExist = createResourceObject(false);
 574         resourceExist.setIcon(null);
 575
 576         try {
 577             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 578         } catch (ByActionStatusComponentException e) {
 579             assertComponentException(e, ActionStatus.COMPONENT_MISSING_ICON, ComponentTypeEnum.RESOURCE.getValue());
 580         }
 581     }
 582
 583     private void testResourceIconInvalid() {
 584         Resource resourceExist = createResourceObject(false);
 585         resourceExist.setIcon("kjk3453^&");
 586
 587         try {
 588             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 589         } catch (ByActionStatusComponentException e) {
 590             assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue());
 591         }
 592     }
 593
 594     private void testResourceIconExceedsLimit() {
 595         Resource resourceExist = createResourceObject(false);
 596         resourceExist.setIcon("dsjfhskdfhskjdhfskjdhkjdhfkshdfksjsdkfhsdfsdfsdfsfsdfsf");
 597         try {
 598             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 599         } catch (ByActionStatusComponentException e) {
 600             assertComponentException(e, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.ICON_MAX_LENGTH);
 601         }
 602     }
 603
 604     // Resource icon end
 605     // Resource tags - start
 606     private void testResourceTagNotExist() {
 607         Resource resourceExist = createResourceObject(false);
 608         resourceExist.setTags(null);
 609         try {
 610             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 611         } catch (ByActionStatusComponentException e) {
 612             assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS);
 613         }
 614     }
 615
 616     private void testResourceTagEmpty() {
 617         Resource resourceExist = createResourceObject(false);
 618         resourceExist.setTags(new ArrayList<>());
 619         try {
 620             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 621         } catch (ByActionStatusComponentException e) {
 622             assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS);
 623         }
 624     }
 625
 626     private void testTagsExceedsLimitCreate() {
 627         Resource resourceExccedsNameLimit = createResourceObject(false);
 628         String tag1 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjQ";
 629         String tag2 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjW";
 630         String tag3 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjE";
 631         String tag4 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjb";
 632         String tag5 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjr";
 633         String tag6 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
 634         String tag7 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
 635         String tag8 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjd";
 636         String tag9 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
 637         String tag10 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
 638         String tag11 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjh";
 639         String tag12 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjj";
 640         String tag13 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjk";
 641         String tag14 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjs";
 642         String tag15 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjz";
 643         String tag16 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjx";
 644         String tag17 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj2";
 645         String tag18 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj3";
 646         String tag19 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj4";
 647         String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
 648         String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
 649
 650         List<String> tagsList = new ArrayList<>();
 651         tagsList.add(tag1);
 652         tagsList.add(tag2);
 653         tagsList.add(tag3);
 654         tagsList.add(tag4);
 655         tagsList.add(tag5);
 656         tagsList.add(tag6);
 657         tagsList.add(tag7);
 658         tagsList.add(tag8);
 659         tagsList.add(tag9);
 660         tagsList.add(tag10);
 661         tagsList.add(tag11);
 662         tagsList.add(tag12);
 663         tagsList.add(tag13);
 664         tagsList.add(tag14);
 665         tagsList.add(tag15);
 666         tagsList.add(tag16);
 667         tagsList.add(tag17);
 668         tagsList.add(tag18);
 669         tagsList.add(tag19);
 670         tagsList.add(tag20);
 671         tagsList.add(tag21);
 672         tagsList.add(resourceExccedsNameLimit.getName());
 673
 674         resourceExccedsNameLimit.setTags(tagsList);
 675         try {
 676             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 677         } catch (ByActionStatusComponentException e) {
 678             assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, "" + ValidationUtils.TAG_LIST_MAX_LENGTH);
 679         }
 680     }
 681
 682     private void testTagsSingleExceedsLimit() {
 683         Resource resourceExccedsNameLimit = createResourceObject(false);
 684         String tag1 = "afzs2qLBb5X6tZhiunkcEwiFX1qRQY8YZl3y3Du5M5xeQY5Nq9afcFHDZ9HaURw43gH27nAUWM36bMbMylwTFSzzNV8NO4v4ripe6Q15Vc2nPOFI";
 685         String tag2 = resourceExccedsNameLimit.getName();
 686         List<String> tagsList = new ArrayList<>();
 687         tagsList.add(tag1);
 688         tagsList.add(tag2);
 689
 690         resourceExccedsNameLimit.setTags(tagsList);
 691         try {
 692             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 693         } catch (ByActionStatusComponentException e) {
 694             assertComponentException(e, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT, "" + ValidationUtils.TAG_MAX_LENGTH);
 695         }
 696     }
 697
 698     private void testTagsNoServiceName() {
 699         Resource serviceExccedsNameLimit = createResourceObject(false);
 700         String tag1 = "afzs2qLBb";
 701         List<String> tagsList = new ArrayList<>();
 702         tagsList.add(tag1);
 703         serviceExccedsNameLimit.setTags(tagsList);
 704         try {
 705             bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 706         } catch (ByActionStatusComponentException e) {
 707             assertComponentException(e, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME);
 708         }
 709     }
 710
 711     private void testInvalidTag() {
 712         Resource serviceExccedsNameLimit = createResourceObject(false);
 713         String tag1 = "afzs2qLBb%#%";
 714         List<String> tagsList = new ArrayList<>();
 715         tagsList.add(tag1);
 716         serviceExccedsNameLimit.setTags(tagsList);
 717         try {
 718             bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 719         } catch (ByActionStatusComponentException e) {
 720             assertComponentException(e, ActionStatus.INVALID_FIELD_FORMAT, new String[]{"Resource", "tag"});
 721         }
 722     }
 723
 724     // Resource tags - stop
 725     // Resource contact start
 726
 727     private void testContactIdTooLong() {
 728         Resource resourceContactId = createResourceObject(false);
 729         // 59 chars instead of 50
 730         String contactIdTooLong = "thisNameIsVeryLongAndExeccedsTheNormalLengthForContactId";
 731         resourceContactId.setContactId(contactIdTooLong);
 732
 733         try {
 734             bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 735         } catch (ByActionStatusComponentException e) {
 736             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 737         }
 738     }
 739
 740     private void testContactIdWrongFormatCreate() {
 741         Resource resourceContactId = createResourceObject(false);
 742         // 3 letters and 3 digits and special characters
 743         String contactIdFormatWrong = "yrt134!!!";
 744         resourceContactId.setContactId(contactIdFormatWrong);
 745         try {
 746             bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 747         } catch (ByActionStatusComponentException e) {
 748             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 749         }
 750     }
 751
 752     private void testResourceContactIdEmpty() {
 753         Resource resourceExist = createResourceObject(false);
 754         resourceExist.setContactId("");
 755         try {
 756             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 757         } catch (ByActionStatusComponentException e) {
 758             assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 759         }
 760     }
 761
 762     private void testResourceContactIdMissing() {
 763         Resource resourceExist = createResourceObject(false);
 764         resourceExist.setContactId(null);
 765         try {
 766             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 767         } catch (ByActionStatusComponentException e) {
 768             assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue());
 769         }
 770     }
 771
 772     private void testVendorNameExceedsLimit() {
 773         Resource resourceExccedsVendorNameLimit = createResourceObject(false);
 774         String tooLongVendorName = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
 775         resourceExccedsVendorNameLimit.setVendorName(tooLongVendorName);
 776         try {
 777             bl.createResource(resourceExccedsVendorNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 778         } catch (ByActionStatusComponentException e) {
 779             assertComponentException(e, ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
 780         }
 781     }
 782
 783     private void testResourceVendorModelNumberExceedsLimit() {
 784         Resource resourceExccedsVendorModelNumberLimit = createResourceObject(false);
 785         String tooLongVendorModelNumber = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
 786         resourceExccedsVendorModelNumberLimit.setResourceVendorModelNumber(tooLongVendorModelNumber);
 787         try {
 788             bl.createResource(resourceExccedsVendorModelNumberLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 789         } catch (ByActionStatusComponentException e) {
 790             assertComponentException(e, ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT, "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
 791         }
 792     }
 793
 794     private void testVendorNameWrongFormatCreate() {
 795         Resource resource = createResourceObject(false);
 796         // contains *
 797         String nameWrongFormat = "ljg*fd";
 798         resource.setVendorName(nameWrongFormat);
 799         try {
 800             bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 801         } catch (ByActionStatusComponentException e) {
 802             assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME);
 803         }
 804     }
 805
 806     private void testVendorReleaseWrongFormat() {
 807         Resource resource = createResourceObject(false);
 808         // contains >
 809         String nameWrongFormat = "1>2";
 810         resource.setVendorRelease(nameWrongFormat);
 811         try {
 812             bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 813         } catch (ByActionStatusComponentException e) {
 814             assertComponentException(e, ActionStatus.INVALID_VENDOR_RELEASE);
 815         }
 816     }
 817
 818     private void testVendorReleaseExceedsLimitCreate() {
 819         Resource resourceExccedsNameLimit = createResourceObject(false);
 820         String tooLongVendorRelease = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E";
 821         resourceExccedsNameLimit.setVendorRelease(tooLongVendorRelease);
 822         try {
 823             bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 824         } catch (ByActionStatusComponentException e) {
 825             assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
 826         }
 827     }
 828
 829     private void testResourceVendorNameMissing() {
 830         Resource resourceExist = createResourceObject(false);
 831         resourceExist.setVendorName(null);
 832         try {
 833             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 834         } catch (ByActionStatusComponentException e) {
 835             assertComponentException(e, ActionStatus.MISSING_VENDOR_NAME);
 836         }
 837     }
 838
 839     private void testResourceVendorReleaseMissing() {
 840         Resource resourceExist = createResourceObject(false);
 841         resourceExist.setVendorRelease(null);
 842         try {
 843             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 844         } catch (ByActionStatusComponentException e) {
 845             assertComponentException(e, ActionStatus.MISSING_VENDOR_RELEASE);
 846         }
 847     }
 848
 849     // Resource vendor name/release stop
 850     // Category start
 851     private void testResourceCategoryExist() {
 852         Resource resourceExist = createResourceObject(false);
 853         resourceExist.setCategories(null);
 854         try {
 855             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 856         } catch (ByActionStatusComponentException e) {
 857             assertComponentException(e, ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
 858         }
 859     }
 860
 861     private void testResourceBadCategoryCreate() {
 862
 863         Resource resourceExist = createResourceObject(false);
 864         resourceExist.setCategories(null);
 865         resourceExist.addCategory("koko", "koko");
 866         try {
 867             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 868         } catch (ByActionStatusComponentException e) {
 869             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
 870         }
 871     }
 872
 873     // Category stop
 874     // Cost start
 875     private void testHappyScenarioCostLicenseType() {
 876         Resource createResourceObject = createResourceObject(false);
 877         Resource createResourceObjectAfterCreate = createResourceObject(true);
 878         // Adding cost and licenseType to basic mock
 879         Either<Resource, StorageOperationStatus> eitherCreate = Either.left(createResourceObjectAfterCreate);
 880         when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
 881
 882         String cost = "123.456";
 883         String licenseType = "User";
 884         createResourceObject.setCost(cost);
 885         createResourceObject.setLicenseType(licenseType);
 886         Resource createdResource;
 887         try{
 888             createdResource = bl.createResource(createResourceObject, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 889             createResourceObjectAfterCreate.setCost(cost);
 890             createResourceObjectAfterCreate.setLicenseType(licenseType);
 891             assertThat(createResourceObjectAfterCreate).isEqualTo(createdResource);
 892         }catch(ByResponseFormatComponentException e){
 893             assertThat(new Integer(200)).isEqualTo(e.getResponseFormat().getStatus());
 894         }
 895     }
 896
 897     private void testCostWrongFormatCreate() {
 898         Resource resourceCost = createResourceObject(false);
 899         // Comma instead of fullstop
 900         String cost = "12356,464";
 901         resourceCost.setCost(cost);
 902         try {
 903             bl.createResource(resourceCost, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 904         } catch (ByActionStatusComponentException e) {
 905             assertComponentException(e, ActionStatus.INVALID_CONTENT);
 906         }
 907     }
 908
 909     // Cost stop
 910     // License type start
 911     private void testLicenseTypeWrongFormatCreate() {
 912         Resource resourceLicenseType = createResourceObject(false);
 913         // lowcase
 914         String licenseType = "cpu";
 915         resourceLicenseType.setLicenseType(licenseType);
 916         try {
 917             bl.createResource(resourceLicenseType, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 918         } catch (ByActionStatusComponentException e) {
 919             assertComponentException(e, ActionStatus.INVALID_CONTENT);
 920         }
 921     }
 922
 923     // License type stop
 924     // Derived from start
 925     private void testResourceTemplateNotExist() {
 926         Resource resourceExist = createResourceObject(false);
 927         List<String> list = null;
 928         resourceExist.setDerivedFrom(list);
 929         try {
 930             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 931         } catch (ByActionStatusComponentException e) {
 932             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
 933         }
 934     }
 935
 936     private void testResourceTemplateEmpty() {
 937         Resource resourceExist = createResourceObject(false);
 938         resourceExist.setDerivedFrom(new ArrayList<>());
 939         try {
 940             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 941         } catch (ByActionStatusComponentException e) {
 942             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
 943         }
 944     }
 945
 946     private void testResourceTemplateInvalid() {
 947         Resource resourceExist = createResourceObject(false);
 948         ArrayList<String> derivedFrom = new ArrayList<>();
 949         derivedFrom.add("kuku");
 950         resourceExist.setDerivedFrom(derivedFrom);
 951         try {
 952             bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
 953         } catch (ByResponseFormatComponentException e) {
 954             assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
 955         } catch (ByActionStatusComponentException e) {
 956             assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
 957         }
 958     }
 959     // Derived from stop
 960     private void assertComponentException(ByResponseFormatComponentException e, ActionStatus expectedStatus, String... variables) {
 961         ResponseFormat actualResponse = e.getResponseFormat();
 962         assertResponse(actualResponse, expectedStatus, variables);
 963     }
 964
 965     private void assertComponentException(ByActionStatusComponentException e, ActionStatus expectedStatus, String... variables) {
 966         ResponseFormat actualResponse = componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
 967         assertResponse(actualResponse, expectedStatus, variables);
 968     }
 969
 970     private void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
 971         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
 972         assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
 973         assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
 974     }
 975
 976     private void assertResponse(Either<Resource, ResponseFormat> createResponse, ActionStatus expectedStatus, String... variables) {
 977         assertResponse(createResponse.right().value(), expectedStatus, variables);
 978     }
 979
 980     // UPDATE tests - start
 981     // Resource name
 982     @Test
 983     public void testResourceNameWrongFormat_UPDATE() {
 984         Resource resource = createResourceObject(true);
 985         Resource updatedResource = createResourceObject(true);
 986
 987         // this is in order to prevent failing with 403 earlier
 988         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
 989         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
 990         // contains *
 991         String nameWrongFormat = "ljg*fd";
 992         updatedResource.setName(nameWrongFormat);
 993
 994         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
 995         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
 996         try {
 997             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
 998         } catch (ByActionStatusComponentException e) {
 999             assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue());
1000         }
1001     }
1002
1003     @Test
1004     public void testResourceNameAfterCertify_UPDATE() {
1005         Resource resource = createResourceObject(true);
1006         Resource updatedResource = createResourceObject(true);
1007
1008         // this is in order to prevent failing with 403 earlier
1009         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1010         // when(resourceOperation.getResource_tx(resource.getUniqueId(),false)).thenReturn(eitherUpdate);
1011         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1012
1013         String name = "ljg";
1014         updatedResource.setName(name);
1015         resource.setVersion("1.0");
1016
1017         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1018         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1019         try {
1020             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1021         } catch (ByActionStatusComponentException e) {
1022             assertComponentException(e, ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED);
1023         }
1024     }
1025
1026     @Test
1027     public void testResourceNameAlreadyExist_UPDATE() {
1028         Resource resource = createResourceObject(true);
1029         Resource updatedResource = createResourceObject(true);
1030
1031         // this is in order to prevent failing with 403 earlier
1032         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1033         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1034
1035         String resourceName = "alreadyExists";
1036         updatedResource.setName(resourceName);
1037         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
1038         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1039         try {
1040             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1041         } catch (ByActionStatusComponentException e) {
1042             assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resourceName);
1043         }
1044     }
1045
1046     //
1047
1048     @Test
1049     public void testResourceDescExceedsLimit_UPDATE() {
1050         Resource resource = createResourceObject(true);
1051         Resource updatedResource = createResourceObject(true);
1052
1053         // this is in order to prevent failing with 403 earlier
1054         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1055         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1056
1057         // 1025 chars, the limit is 1024
1058         String tooLongResourceDesc = "1GUODojQ0sGzKR4NP7e5j82ADQ3KHTVOaezL95qcbuaqDtjZhAQGQ3iFwKAy580K4WiiXs3u3zq7RzXcSASl5fm0RsWtCMOIDP"
1059                 + "AOf9Tf2xtXxPCuCIMCR5wOGnNTaFxgnJEHAGxilBhZDgeMNHmCN1rMK5B5IRJOnZxcpcL1NeG3APTCIMP1lNAxngYulDm9heFSBc8TfXAADq7703AvkJT0QPpGq2z2P"
1060                 + "tlikcAnIjmWgfC5Tm7UH462BAlTyHg4ExnPPL4AO8c92VrD7kZSgSqiy73cN3gLT8uigkKrUgXQFGVUFrXVyyQXYtVM6bLBeuCGQf4C2j8lkNg6M0J3PC0PzMRoinOxk"
1061                 + "Ae2teeCtVcIj4A1KQo3210j8q2v7qQU69Mabsa6DT9FgE4rcrbiFWrg0Zto4SXWD3o1eJA9o29lTg6kxtklH3TuZTmpi5KVp1NFhS1RpnqF83tzv4mZLKsx7Zh1fEgYvRFwx1"
1062                 + "ar3RolyDfNoZiGBGTMsZzz7RPFBf2hTnLmNqVGQnHKhhGj0Y5s8t2cbqbO2nmHiJb9uaUVrCGypgbAcJL3KPOBfAVW8PcpmNj4yVjI3L4x5zHjmGZbp9vKshEQODcrmcgsYAoKqe"
1063                 + "uu5u7jk8XVxEfQ0m5qL8UOErXPlJovSmKUmP5B5T0w299zIWDYCzSoNasHpHjOMDLAiDDeHbozUOn9t3Qou00e9POq4RMM0VnIx1H38nJoJZz2XH8CI5YMQe7oTagaxgQTF2aa0qaq2"
1064                 + "V6nJsfRGRklGjNhFFYP2cS4Xv2IJO9DSX6LTXOmENrGVJJvMOZcvnBaZPfoAHN0LU4i1SoepLzulIxnZBfkUWFJgZ5wQ0Bco2GC1HMqzW21rwy4XHRxXpXbmW8LVyoA1KbnmVmROycU4"
1065                 + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
1066         updatedResource.setDescription(tooLongResourceDesc);
1067         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1068         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1069         try {
1070             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1071         } catch (ByActionStatusComponentException e) {
1072             assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH);
1073         }
1074     }
1075
1076     @Test
1077     public void testIconWrongFormat_UPDATE() {
1078         Resource resource = createResourceObject(true);
1079         Resource updatedResource = createResourceObject(true);
1080
1081         // this is in order to prevent failing with 403 earlier
1082         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1083         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1084
1085         // contains .
1086         String icon = "icon.jpg";
1087         updatedResource.setIcon(icon);
1088         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1089         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1090         try {
1091             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1092         } catch (ByActionStatusComponentException e) {
1093             assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue());
1094         }
1095     }
1096
1097     @Test
1098     public void testIconAfterCertify_UPDATE() {
1099         Resource resource = createResourceObject(true);
1100         Resource updatedResource = createResourceObject(true);
1101
1102         // this is in order to prevent failing with 403 earlier
1103         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1104         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1105
1106         // contains
1107         String icon = "icon";
1108         updatedResource.setIcon(icon);
1109
1110         resource.setVersion("1.0");
1111         ;
1112         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1113         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1114         try {
1115             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1116         } catch (ByActionStatusComponentException e) {
1117             assertComponentException(e, ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED);
1118         }
1119     }
1120
1121     @Test
1122     public void testTagsExceedsLimit_UPDATE() {
1123         Resource resource = createResourceObject(true);
1124         Resource updatedResource = createResourceObject(true);
1125
1126         // this is in order to prevent failing with 403 earlier
1127         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1128         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1129
1130         String tag1 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjQ";
1131         String tag2 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjW";
1132         String tag3 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjE";
1133         String tag4 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjb";
1134         String tag5 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjr";
1135         String tag6 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
1136         String tag7 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
1137         String tag8 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjd";
1138         String tag9 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjf";
1139         String tag10 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjg";
1140         String tag11 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjh";
1141         String tag12 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjj";
1142         String tag13 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjk";
1143         String tag14 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjs";
1144         String tag15 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjz";
1145         String tag16 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBjx";
1146         String tag17 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj2";
1147         String tag18 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj3";
1148         String tag19 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj4";
1149         String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
1150         String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
1151
1152         List<String> tagsList = new ArrayList<>();
1153         tagsList.add(tag1);
1154         tagsList.add(tag2);
1155         tagsList.add(tag3);
1156         tagsList.add(tag4);
1157         tagsList.add(tag5);
1158         tagsList.add(tag6);
1159         tagsList.add(tag7);
1160         tagsList.add(tag8);
1161         tagsList.add(tag9);
1162         tagsList.add(tag10);
1163         tagsList.add(tag11);
1164         tagsList.add(tag12);
1165         tagsList.add(tag13);
1166         tagsList.add(tag14);
1167         tagsList.add(tag15);
1168         tagsList.add(tag16);
1169         tagsList.add(tag17);
1170         tagsList.add(tag18);
1171         tagsList.add(tag19);
1172         tagsList.add(tag20);
1173         tagsList.add(tag21);
1174         tagsList.add(resource.getName());
1175
1176         updatedResource.setTags(tagsList);
1177         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1178         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1179         try {
1180             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1181         } catch (ByActionStatusComponentException e) {
1182             assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, "" + ValidationUtils.TAG_LIST_MAX_LENGTH);
1183         }
1184     }
1185
1186     @Test
1187     public void testVendorNameWrongFormat_UPDATE() {
1188         Resource resource = createResourceObject(true);
1189         Resource updatedResource = createResourceObject(true);
1190
1191         // this is in order to prevent failing with 403 earlier
1192         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1193         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1194
1195         // contains *
1196         String nameWrongFormat = "ljg*fd";
1197         updatedResource.setVendorName(nameWrongFormat);
1198         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1199         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1200         try {
1201             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1202         } catch (ByActionStatusComponentException e) {
1203             assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME);
1204         }
1205     }
1206
1207     @Test
1208     public void testVendorNameWrongFormat() {
1209         Resource resource = createResourceObject(true);
1210         Resource updatedResource = createResourceObject(true);
1211
1212         // this is in order to prevent failing with 403 earlier
1213         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1214         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1215
1216         // contains *
1217         String nameWrongFormat = "ljg*fd";
1218         updatedResource.setVendorName(nameWrongFormat);
1219         resource.setVersion("1.0");
1220         ;
1221         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1222         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1223         try {
1224             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1225         } catch (ByActionStatusComponentException e) {
1226             assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME);
1227         }
1228     }
1229
1230     @Test
1231     public void testVendorReleaseExceedsLimit_UPDATE() {
1232         Resource resource = createResourceObject(true);
1233         Resource updatedResource = createResourceObject(true);
1234
1235         // this is in order to prevent failing with 403 earlier
1236         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1237         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1238         // 129 chars, the limit is 128
1239         String tooLongVendorRelease = "h1KSyJh9EspI8SPwAGu4VETfqWejeanuB1PCJBxJmJncYnrW0lnsEFFVRIukRJkwlOVnZCy8p38tjhANeZq3BGMHIawWR6ICl8Wi9mikRYALWgvJug00JrlQ0iPVKPLxy";
1240         updatedResource.setVendorRelease(tooLongVendorRelease);
1241         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1242         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1243         try {
1244             bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false);
1245         } catch (ByActionStatusComponentException e) {
1246             assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
1247         }
1248     }
1249
1250     @Test
1251     public void testResourceBadCategory_UPDATE() {
1252         Resource resource = createResourceObject(true);
1253         Resource updatedResource = createResourceObject(true);
1254
1255         // this is in order to prevent failing with 403 earlier
1256         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1257         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1258
1259         String resourceId = resource.getUniqueId();
1260         String badCategory = "ddfds";
1261         updatedResource.setCategories(null);
1262         updatedResource.addCategory(badCategory, "fikt");
1263         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1264         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1265         try {
1266             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1267         } catch (ByActionStatusComponentException e) {
1268             assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
1269         }
1270     }
1271
1272     @Test
1273     public void testResourceCategoryAfterCertify_UPDATE() {
1274         Resource resource = createResourceObject(true);
1275         Resource updatedResource = createResourceObject(true);
1276
1277         // this is in order to prevent failing with 403 earlier
1278         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1279         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1280
1281         String resourceId = resource.getUniqueId();
1282         updatedResource.setCategories(null);
1283         updatedResource.addCategory(RESOURCE_CATEGORY1, UPDATED_SUBCATEGORY);
1284         resource.setVersion("1.0");
1285         ;
1286         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1287         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1288         try {
1289             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1290         } catch (ByActionStatusComponentException e) {
1291             assertComponentException(e, ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED);
1292         }
1293     }
1294
1295     // Derived from start
1296     @Test
1297     public void testResourceTemplateNotExist_UPDATE() {
1298         Resource resource = createResourceObject(true);
1299         Resource updatedResource = createResourceObject(true);
1300
1301         // this is in order to prevent failing with 403 earlier
1302         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1303         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1304         String resourceId = resource.getUniqueId();
1305
1306         List<String> list = null;
1307         updatedResource.setDerivedFrom(list);
1308         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1309         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1310         try {
1311             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1312         } catch (ByActionStatusComponentException e) {
1313             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
1314         }
1315     }
1316
1317     @Test
1318     public void testResourceTemplateEmpty_UPDATE() {
1319         Resource resource = createResourceObject(true);
1320         Resource updatedResource = createResourceObject(true);
1321         String resourceId = resource.getUniqueId();
1322
1323         // this is in order to prevent failing with 403 earlier
1324         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1325         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1326
1327         updatedResource.setDerivedFrom(new ArrayList<>());
1328         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1329         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1330         try {
1331             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1332         } catch (ByActionStatusComponentException e) {
1333             assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
1334         }
1335     }
1336
1337     @Test
1338     public void testResourceTemplateInvalid_UPDATE() {
1339         Resource resource = createResourceObject(true);
1340         Resource updatedResource = createResourceObject(true);
1341         String resourceId = resource.getUniqueId();
1342
1343         // this is in order to prevent failing with 403 earlier
1344         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1345         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1346
1347         ArrayList<String> derivedFrom = new ArrayList<>();
1348         derivedFrom.add("kuku");
1349         updatedResource.setDerivedFrom(derivedFrom);
1350         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1351         when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
1352         try {
1353             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1354         } catch (ByActionStatusComponentException e) {
1355             assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND);
1356         }
1357     }
1358
1359     @Test
1360     public void testResourceTemplateCertify_UPDATE_HAPPY() {
1361         Resource resource = createResourceObject(true);
1362         Resource updatedResource = createResourceObject(true);
1363         String resourceId = resource.getUniqueId();
1364
1365         // this is in order to prevent failing with 403 earlier
1366         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1367         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1368
1369         Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(true);
1370         when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString())).thenReturn(isToscaNameExtending);
1371
1372         Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = Either.left(new HashMap<>());
1373         when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), Mockito.anyString())).thenReturn(findPropertiesOfNode);
1374
1375         resource.setVersion("1.0");
1376
1377         ArrayList<String> derivedFrom = new ArrayList<>();
1378         derivedFrom.add("tosca.nodes.Root");
1379         updatedResource.setDerivedFrom(derivedFrom);
1380         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
1381         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1382         Resource createdResource = bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1383         assertThat(createdResource).isNotNull();
1384     }
1385
1386     @Test
1387     public void testResourceTemplateCertify_UPDATE_SAD() {
1388         Resource resource = createResourceObject(true);
1389         Resource updatedResource = createResourceObject(true);
1390         String resourceId = resource.getUniqueId();
1391
1392         // this is in order to prevent failing with 403 earlier
1393         Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
1394         when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
1395
1396         Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(false);
1397         when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString()))
1398                 .thenReturn(isToscaNameExtending);
1399
1400         resource.setVersion("1.0");
1401
1402         ArrayList<String> derivedFrom = new ArrayList<>();
1403         derivedFrom.add("tosca.nodes.Root");
1404         updatedResource.setDerivedFrom(derivedFrom);
1405         Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
1406         when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
1407         Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = Either.left(new HashMap<>());
1408         when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), Mockito.anyString())).thenReturn(findPropertiesOfNode);
1409
1410         try {
1411             bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
1412         } catch (ByActionStatusComponentException e) {
1413             assertComponentException(e, ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND);
1414         }
1415     }
1416     // Derived from stop
1417
1418     @Test
1419     public void createOrUpdateResourceAlreadyCheckout() {
1420         Resource resourceExist = createResourceObject(false);
1421         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1422         Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1423         createdResource.setLastUpdaterUserId(user.getUserId());
1424         assertThat(createdResource).isNotNull();
1425         Either<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
1426         Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(createdResource);
1427         when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())).thenReturn(getCompLatestResult);
1428         when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(getLatestResult);
1429
1430         Resource resourceToUpdtae = createResourceObject(false);
1431
1432         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1433         assertNotNull(createOrUpdateResource);
1434
1435         Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1436         Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1437
1438     }
1439
1440     @Test
1441     public void createOrUpdateResourceCertified() {
1442         Resource resourceExist = createResourceObject(false);
1443         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1444         Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1445
1446         assertThat(createdResource).isNotNull();
1447         createdResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1448         createdResource.setVersion("1.0");
1449
1450         Either<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
1451         Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(createdResource);
1452         when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())).thenReturn(getCompLatestResult);        when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(getLatestResult);
1453
1454         when(lifecycleBl.changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean())).thenReturn(Either.left(createdResource));
1455
1456         Resource resourceToUpdtae = createResourceObject(false);
1457
1458         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1459         assertNotNull(createOrUpdateResource);
1460
1461         Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1462         Mockito.verify(lifecycleBl, Mockito.times(1)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1463
1464     }
1465
1466     @Test
1467     public void createOrUpdateResourceNotExist() {
1468         Resource resourceToUpdtae = createResourceObject(false);
1469
1470         Either<Component, StorageOperationStatus> getLatestResult = Either.right(StorageOperationStatus.NOT_FOUND);
1471         when(toscaOperationFacade.getLatestByName(resourceToUpdtae.getName())).thenReturn(getLatestResult);
1472
1473         Either<Component, StorageOperationStatus> getLatestToscaNameResult = Either.right(StorageOperationStatus.NOT_FOUND);
1474         when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdtae.getToscaResourceName())).thenReturn(getLatestToscaNameResult);
1475
1476         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false);
1477         assertThat(createOrUpdateResource).isNotNull();
1478
1479         Mockito.verify(toscaOperationFacade, times(1)).createToscaComponent(eq(resourceToUpdtae));
1480         Mockito.verify(toscaOperationFacade, Mockito.times(0)).overrideComponent(any(Resource.class), any(Resource.class));
1481         Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1482
1483     }
1484
1485     @Test
1486     public void updateNestedResource_typeIsNew() throws IOException {
1487         Resource resourceToUpdate = createResourceObject(false);
1488         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc";
1489         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
1490         CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(),
1491                 RESOURCE_NAME, "template name", jsonContent, true);
1492         String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight();
1493         when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1494         when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1495         when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1496
1497         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo,
1498                 nodeName, false);
1499         assertThat(createOrUpdateResource).isNotNull();
1500
1501         Mockito.verify(toscaOperationFacade, times(1)).createToscaComponent(eq(resourceToUpdate));
1502         Mockito.verify(toscaOperationFacade, times(0)).overrideComponent(any(Resource.class), any(Resource.class));
1503         Mockito.verify(lifecycleBl, times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1504     }
1505
1506     @Test
1507     public void updateNestedResource_typeExists() throws IOException {
1508         Resource resourceToUpdate = createResourceObject(false);
1509         setCanWorkOnResource(resourceResponse);
1510         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc";
1511         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
1512         CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(),
1513                 RESOURCE_NAME, "template name", jsonContent, true);
1514         String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType().name(), csarInfo.getVfResourceName(), nodeName).getRight();
1515         when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1516         when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1517         when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)).thenReturn(Either.left(resourceResponse));
1518         when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))).thenReturn(Either.left(resourceResponse));
1519
1520         ImmutablePair<Resource, ActionStatus> createOrUpdateResource = bl.createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo,
1521                 nodeName, false);
1522         assertThat(createOrUpdateResource).isNotNull();
1523         Mockito.verify(toscaOperationFacade, times(1)).overrideComponent(any(Resource.class), any(Resource.class));
1524         Mockito.verify(lifecycleBl, times(0)).changeState(Mockito.anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean());
1525     }
1526
1527     @Test
1528     public void testValidatePropertiesDefaultValues_SuccessfullWithoutProperties() {
1529         Resource basic = createResourceObject(true);
1530
1531         Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1532         assertTrue(validatePropertiesDefaultValues.isLeft());
1533     }
1534
1535     @Test
1536     public void testValidatePropertiesDefaultValues_SuccessfullWithProperties() {
1537         Resource basic = createResourceObject(true);
1538         PropertyDefinition property = new PropertyDefinition();
1539         property.setName("myProperty");
1540         property.setType(ToscaPropertyType.INTEGER.getType());
1541         property.setDefaultValue("1");
1542         List<PropertyDefinition> properties = new ArrayList<>();
1543         properties.add(property);
1544         basic.setProperties(properties);
1545         when(propertyOperation.isPropertyTypeValid(property)).thenReturn(true);
1546         when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(true);
1547         Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1548         assertTrue(validatePropertiesDefaultValues.isLeft());
1549     }
1550
1551     @Test
1552     public void testValidatePropertiesDefaultValues_FailedWithProperties() {
1553         Resource basic = createResourceObject(true);
1554         PropertyDefinition property = new PropertyDefinition();
1555         property.setName("myProperty");
1556         property.setType(ToscaPropertyType.INTEGER.getType());
1557         property.setDefaultValue("1.5");
1558         List<PropertyDefinition> properties = new ArrayList<>();
1559         properties.add(property);
1560         basic.setProperties(properties);
1561
1562         when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(false);
1563         Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
1564         assertTrue(validatePropertiesDefaultValues.isRight());
1565     }
1566
1567
1568     @SuppressWarnings("unchecked")
1569     @Test
1570     public void testFindVfCsarArtifactsToHandle() {
1571
1572         Class<ResourceBusinessLogic> targetClass = ResourceBusinessLogic.class;
1573         String methodName = "findVfCsarArtifactsToHandle";
1574         Resource resource = new Resource();
1575         String deploymentArtifactToUpdateFileName = "deploymentArtifactToUpdate.yaml";
1576         String deploymentArtifactToDeleteFileName = "deploymentArtifactToDelete.yaml";
1577         String deploymentArtifactToCreateFileName = "deploymentArtifactToCreate.yaml";
1578
1579         String artifactInfoToUpdateFileName = "infoArtifactToUpdate.yaml";
1580         String artifactInfoToDeleteFileName = "infoArtifactToDelete.yaml";
1581         String artifactInfoToNotDeleteFileName = "infoArtifactNotToDelete.yaml";
1582         String artifactInfoToCreateFileName = "infoArtifactToCreate.yaml";
1583
1584         byte[] oldPayloadData = "oldPayloadData".getBytes();
1585         byte[] newPayloadData = "newPayloadData".getBytes();
1586         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
1587
1588         ArtifactDefinition deploymentArtifactToUpdate = new ArtifactDefinition();
1589         deploymentArtifactToUpdate.setMandatory(false);
1590         deploymentArtifactToUpdate.setArtifactName(deploymentArtifactToUpdateFileName);
1591         deploymentArtifactToUpdate.setArtifactType("SNMP_POLL");
1592         deploymentArtifactToUpdate.setPayload(oldPayloadData);
1593         deploymentArtifactToUpdate.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1594
1595         ArtifactDefinition deploymentArtifactToDelete = new ArtifactDefinition();
1596         deploymentArtifactToDelete.setMandatory(false);
1597         deploymentArtifactToDelete.setArtifactName(deploymentArtifactToDeleteFileName);
1598         deploymentArtifactToDelete.setArtifactType("SNMP_TRAP");
1599         deploymentArtifactToDelete.setPayload(oldPayloadData);
1600         deploymentArtifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1601
1602         ArtifactDefinition deploymentArtifactToIgnore = new ArtifactDefinition();
1603
1604         deploymentArtifacts.put(ValidationUtils.normalizeArtifactLabel(deploymentArtifactToUpdate.getArtifactName()), deploymentArtifactToUpdate);
1605         deploymentArtifacts.put(ValidationUtils.normalizeArtifactLabel(deploymentArtifactToDelete.getArtifactName()), deploymentArtifactToDelete);
1606         deploymentArtifacts.put("ignore", deploymentArtifactToIgnore);
1607
1608         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
1609
1610         ArtifactDefinition artifactToUpdate = new ArtifactDefinition();
1611         artifactToUpdate.setMandatory(false);
1612         artifactToUpdate.setArtifactName(artifactInfoToUpdateFileName);
1613         artifactToUpdate.setArtifactType("SNMP_POLL");
1614         artifactToUpdate.setPayload(oldPayloadData);
1615         artifactToUpdate.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1616
1617         ArtifactDefinition artifactToDelete = new ArtifactDefinition();
1618         artifactToDelete.setMandatory(false);
1619         artifactToDelete.setArtifactName(artifactInfoToDeleteFileName);
1620         artifactToDelete.setArtifactType("SNMP_TRAP");
1621         artifactToDelete.setPayload(oldPayloadData);
1622         artifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1623         artifactToDelete.setIsFromCsar(true);
1624
1625         ArtifactDefinition artifactToNotDelete = new ArtifactDefinition();
1626         artifactToNotDelete.setMandatory(false);
1627         artifactToNotDelete.setArtifactName(artifactInfoToNotDeleteFileName);
1628         artifactToNotDelete.setArtifactType("SNMP_TRAP");
1629         artifactToNotDelete.setPayload(oldPayloadData);
1630         artifactToNotDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData));
1631         artifactToNotDelete.setIsFromCsar(false);
1632
1633         ArtifactDefinition artifactToIgnore = new ArtifactDefinition();
1634
1635         artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToUpdate.getArtifactName()), artifactToUpdate);
1636         artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToDelete.getArtifactName()), artifactToDelete);
1637         artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToNotDelete.getArtifactName()), artifactToNotDelete);
1638         artifacts.put("ignore", artifactToIgnore);
1639
1640         resource.setDeploymentArtifacts(deploymentArtifacts);
1641         resource.setArtifacts(artifacts);
1642
1643         List<NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
1644         NonMetaArtifactInfo deploymentArtifactInfoToUpdate = new NonMetaArtifactInfo(deploymentArtifactToUpdate.getArtifactName(), null,
1645                 ArtifactTypeEnum.findType(deploymentArtifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1646                 newPayloadData, deploymentArtifactToUpdate.getArtifactName(), false);
1647
1648         NonMetaArtifactInfo informationalArtifactInfoToUpdate = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1649                 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1650                 newPayloadData, artifactToUpdate.getArtifactName(), false);
1651
1652         NonMetaArtifactInfo informationalArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1653                 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.INFORMATIONAL,
1654                 newPayloadData, artifactToUpdate.getArtifactName(), true);
1655
1656         NonMetaArtifactInfo deploymentArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo(artifactToUpdate.getArtifactName(), null,
1657                 ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), ArtifactGroupTypeEnum.DEPLOYMENT,
1658                 newPayloadData, artifactToUpdate.getArtifactName(), true);
1659
1660         NonMetaArtifactInfo deploymentArtifactInfoToCreate = new NonMetaArtifactInfo(deploymentArtifactToCreateFileName, null,
1661                 ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, deploymentArtifactToCreateFileName, false);
1662
1663         NonMetaArtifactInfo informationalArtifactInfoToCreate = new NonMetaArtifactInfo(artifactInfoToCreateFileName, null,
1664                 ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.INFORMATIONAL,
1665                 newPayloadData, artifactInfoToCreateFileName, false);
1666
1667         artifactPathAndNameList.add(deploymentArtifactInfoToUpdate);
1668         artifactPathAndNameList.add(informationalArtifactInfoToUpdate);
1669         artifactPathAndNameList.add(deploymentArtifactInfoToCreate);
1670         artifactPathAndNameList.add(informationalArtifactInfoToCreate);
1671         artifactPathAndNameList.add(informationalArtifactInfoToUpdateFromCsar);
1672         artifactPathAndNameList.add(deploymentArtifactInfoToUpdateFromCsar);
1673
1674         Object[] argObjects = {resource, artifactPathAndNameList, user};
1675         Class[] argClasses = {Resource.class, List.class, User.class};
1676         try {
1677             Method method = targetClass.getDeclaredMethod(methodName, argClasses);
1678             method.setAccessible(true);
1679             Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes =
1680                     (Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat>) method.invoke(bl, argObjects);
1681             assertTrue(findVfCsarArtifactsToHandleRes.isLeft());
1682             EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> foundVfArtifacts = findVfCsarArtifactsToHandleRes.left().value();
1683             assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.CREATE).size());
1684             assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.UPDATE).size());
1685             assertEquals(1, foundVfArtifacts.get(ArtifactOperationEnum.DELETE).size());
1686
1687         } catch (Exception e) {
1688             e.printStackTrace();
1689         }
1690     }
1691
1692     @Test
1693     public void testVFGeneratedInputs() {
1694         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1695         Resource resource = createVF();
1696         List<InputDefinition> inputs = resource.getInputs();
1697         assertEquals(6, inputs.size());
1698         for (InputDefinition input : inputs) {
1699             assertThat(input.getOwnerId()).isNotNull();
1700         }
1701         assertEquals(resource.getDerivedFromGenericType(), genericVF.getToscaResourceName());
1702         assertEquals(resource.getDerivedFromGenericVersion(), genericVF.getVersion());
1703     }
1704
1705     @Test
1706     public void testCRGeneratedInputs() {
1707         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1708         Resource resource = createCR();
1709         List<InputDefinition> inputs = resource.getInputs();
1710         assertEquals(3, inputs.size());
1711         for (InputDefinition input : inputs) {
1712             assertThat(input.getOwnerId()).isNotNull();
1713         }
1714         assertEquals(resource.getDerivedFromGenericType(), genericCR.getToscaResourceName());
1715         assertEquals(resource.getDerivedFromGenericVersion(), genericCR.getVersion());
1716     }
1717
1718     @Test
1719     public void testVFUpdateGenericInputsToLatestOnCheckout() {
1720         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1721         //create a VF that is derived from generic version 1.0
1722         Resource resource = createVF();
1723         // create a new generic version without properties
1724         genericVF.setVersion("2.0");
1725         genericVF.setProperties(null);
1726         String currentDerivedFromVersion = resource.getDerivedFromGenericVersion();
1727         List<InputDefinition> currentInputs = resource.getInputs();
1728         //verify previous inputs ownerId fields exist - user may not delete generated inputs
1729         assertEquals(6, currentInputs.stream().filter(p -> null != p.getOwnerId()).collect(Collectors.toList()).size());
1730         Either<Boolean, ResponseFormat> upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource);
1731         //verify success
1732         assertTrue(upgradeToLatestGeneric.isLeft());
1733         //verify update required and valid
1734         assertTrue(upgradeToLatestGeneric.left().value());
1735         //verify version was upgraded
1736         assertNotEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion);
1737         //verify inputs were not deleted
1738         assertEquals(6, resource.getInputs().size());
1739         //verify inputs ownerId fields were removed - user may delete/edit inputs
1740         assertEquals(6, resource.getInputs()
1741                                 .stream()
1742                                 .filter(p -> null == p.getOwnerId())
1743                                 .collect(Collectors.toList())
1744                                 .size());
1745     }
1746
1747
1748     @Test
1749     public void testVFUpdateGenericInputsToLatestOnCheckoutNotPerformed() {
1750
1751         //create a VF that is derived from generic version 1.0
1752         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1753         Resource resource = createVF();
1754
1755         //add an input to the VF
1756         PropertyDefinition newProp = new PropertyDefinition();
1757         newProp.setType("integer");
1758         newProp.setName("newProp");
1759         resource.getInputs().add(new InputDefinition(newProp));
1760
1761         //create a new generic version with a new property which has the same name as a user defined input on the VF with a different type
1762         genericVF.setVersion("2.0");
1763         newProp.setType("string");
1764         genericVF.setProperties(new ArrayList<>());
1765         genericVF.getProperties().add(newProp);
1766         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF));
1767         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), genericVF.getUniqueId())).thenCallRealMethod();
1768         String currentDerivedFromVersion = resource.getDerivedFromGenericVersion();
1769         assertEquals(6, resource.getInputs()
1770                                 .stream()
1771                                 .filter(p -> null != p.getOwnerId())
1772                                 .collect(Collectors.toList())
1773                                 .size());
1774         Either<Boolean, ResponseFormat> upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource);
1775         //verify success
1776         assertTrue(upgradeToLatestGeneric.isLeft());
1777         //verify update is invalid an void
1778         assertFalse(upgradeToLatestGeneric.left().value());
1779         //verify version was not upgraded
1780         assertEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion);
1781         //verify inputs were not removed
1782         assertEquals(7, resource.getInputs().size());
1783         //verify user defined input exists
1784         assertEquals(1, resource.getInputs()
1785                                 .stream()
1786                                 .filter(p -> null == p.getOwnerId())
1787                                 .collect(Collectors.toList())
1788                                 .size());
1789         assertEquals("integer", resource.getInputs()
1790                                         .stream()
1791                                         .filter(p -> null == p.getOwnerId())
1792                                         .findAny()
1793                                         .get()
1794                                         .getType());
1795     }
1796
1797     @Test
1798     public void testPNFGeneratedInputsNoGeneratedInformationalArtifacts() {
1799         validateUserRoles(Role.ADMIN, Role.DESIGNER);
1800         Resource resource = createPNF();
1801         List<InputDefinition> inputs = resource.getInputs();
1802         assertEquals(3, inputs.size());
1803         for (InputDefinition input : inputs) {
1804             assertThat(input.getOwnerId()).isNotNull();
1805         }
1806         assertEquals(resource.getDerivedFromGenericType(), genericPNF.getToscaResourceName());
1807         assertEquals(resource.getDerivedFromGenericVersion(), genericPNF.getVersion());
1808         assertEquals(0, resource.getArtifacts().size());
1809     }
1810
1811
1812     private Resource createVF() {
1813
1814         genericVF = setupGenericTypeMock(GENERIC_VF_NAME);
1815         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_VF_NAME)).thenReturn(Either.left(genericVF));
1816         Resource resource = createResourceObject(true);
1817         resource.setDerivedFrom(null);
1818         resource.setResourceType(ResourceTypeEnum.VF);
1819         when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1820         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF));
1821         when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericVF)).thenCallRealMethod();
1822         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1823         Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1824         assertThat(createdResource).isNotNull();
1825         return createdResource;
1826     }
1827
1828
1829     private Resource createCR() {
1830
1831         genericCR = setupGenericTypeMock(GENERIC_CR_NAME);
1832         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_CR_NAME)).thenReturn(Either.left(genericCR));
1833         Resource resource = createResourceObject(true);
1834         resource.setDerivedFrom(null);
1835         resource.setResourceType(ResourceTypeEnum.CR);
1836         when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1837         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericCR));
1838         when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericCR)).thenCallRealMethod();
1839         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericCR.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1840         Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1841         assertThat(createdResource).isNotNull();
1842         return createdResource;
1843     }
1844
1845     private Resource createPNF() {
1846
1847         genericPNF = setupGenericTypeMock(GENERIC_PNF_NAME);
1848         when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_PNF_NAME)).thenReturn(Either.left(genericPNF));
1849         Resource resource = createResourceObject(true);
1850         resource.setDerivedFrom(null);
1851         resource.setResourceType(ResourceTypeEnum.PNF);
1852         when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
1853         when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericPNF));
1854         when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericPNF)).thenCallRealMethod();
1855         when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericPNF.getProperties(), resource.getUniqueId())).thenCallRealMethod();
1856         Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null);
1857         assertThat(createdResource).isNotNull();
1858         return createdResource;
1859     }
1860
1861
1862     private Map<String, String> getGenericPropertiesByToscaName(String toscaName) {
1863         HashMap<String, String> PNFProps = new HashMap<String, String>() {{
1864             put("nf_function", "string");
1865             put("nf_role", "string");
1866             put("nf_type", "string");
1867         }};
1868
1869         HashMap<String, String> CRProps = new HashMap<String, String>() {{
1870             put("cr_function", "string");
1871             put("cr_role", "string");
1872             put("cr_type", "string");
1873         }};
1874
1875         HashMap<String, String> VFProps = new HashMap<String, String>() {{
1876             putAll(CRProps);
1877             put("availability_zone_max_count", "integer");
1878             put("min_instances", "integer");
1879             put("max_instances", "integer");
1880         }};
1881
1882         if (toscaName.contains("PNF")) return PNFProps;
1883         if (toscaName.contains("CR")) return CRProps;
1884         if (toscaName.contains("VF")) return VFProps;
1885
1886         return new HashMap<>();
1887     }
1888
1889
1890     private Resource setupGenericTypeMock(String toscaName) {
1891
1892         Resource genericType = createResourceObject(true);
1893         genericType.setVersion("1.0");
1894         genericType.setToscaResourceName(toscaName);
1895         List<PropertyDefinition> genericProps = new ArrayList<>();
1896         Map<String, String> genericPropsMap = getGenericPropertiesByToscaName(toscaName);
1897         genericPropsMap.forEach((name, type) -> {
1898             PropertyDefinition prop = new PropertyDefinition();
1899             prop.setName(name);
1900             prop.setType(type);
1901             genericProps.add(prop);
1902         });
1903
1904         genericType.setProperties(genericProps);
1905         return genericType;
1906     }
1907
1908     private void validateUserRoles(Role... roles) {
1909         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
1910     }
1911
1912
1913     @Test
1914     public void testgetAllCertifiedResources() throws Exception {
1915         List<Resource> list = bl.getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, "USER");
1916         Assert.assertEquals(reslist,list);
1917     }
1918
1919     @Test(expected = StorageException.class)
1920     public void testgetAllCertifiedResources_exception() throws Exception {
1921         List<Resource> list = bl.getAllCertifiedResources(false, HighestFilterEnum.NON_HIGHEST_ONLY, "USER");
1922         Assert.assertEquals(reslist,list);
1923     }
1924
1925     @Test
1926     public void testvalidateResourceNameExists() throws Exception {
1927         Either<Map<String, Boolean>, ResponseFormat> res = bl.validateResourceNameExists("Resource", ResourceTypeEnum.CR, "jh0003");
1928         Assert.assertEquals(true,res.isLeft());
1929     }
1930
1931
1932 }