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