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