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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  * ================================================================================
  16  * Modifications copyright (c) 2019 Nokia
  17  * ================================================================================
  18  */
  19
  20 package org.openecomp.sdc.be.components.impl;
  21
  22 import fj.data.Either;
  23 import org.junit.Assert;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.mockito.Mockito;
  27 import org.mockito.MockitoAnnotations;
  28 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  29 import org.openecomp.sdc.be.components.validation.CapabilitiesValidation;
  30 import org.openecomp.sdc.be.components.validation.UserValidations;
  31 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  32 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  33 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  34 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  35 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  36 import org.openecomp.sdc.be.impl.ComponentsUtils;
  37 import org.openecomp.sdc.be.model.CapabilityDefinition;
  38 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  39 import org.openecomp.sdc.be.model.Component;
  40 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  41 import org.openecomp.sdc.be.model.ComponentParametersView;
  42 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  43 import org.openecomp.sdc.be.model.RelationshipInfo;
  44 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  45 import org.openecomp.sdc.be.model.Resource;
  46 import org.openecomp.sdc.be.model.Service;
  47 import org.openecomp.sdc.be.model.User;
  48 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.CapabilitiesOperation;
  49 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  50 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
  51 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  52 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  53 import org.openecomp.sdc.be.user.Role;
  54 import org.openecomp.sdc.be.user.UserBusinessLogic;
  55 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  56 import org.openecomp.sdc.exception.ResponseFormat;
  57
  58 import java.util.ArrayList;
  59 import java.util.Collections;
  60 import java.util.HashMap;
  61 import java.util.List;
  62 import java.util.Map;
  63 import java.util.stream.Collectors;
  64 import java.util.stream.Stream;
  65
  66 import static org.mockito.ArgumentMatchers.any;
  67 import static org.mockito.ArgumentMatchers.anyBoolean;
  68 import static org.mockito.ArgumentMatchers.anyCollection;
  69 import static org.mockito.ArgumentMatchers.anyObject;
  70 import static org.mockito.ArgumentMatchers.anyString;
  71 import static org.mockito.ArgumentMatchers.eq;
  72 import static org.mockito.Mockito.when;
  73
  74 public class CapabilitiesBusinessLogicTest extends BaseBusinessLogicMock {
  75     private final String componentId = "resourceId1";
  76     private final String capabilityId = "uniqueId1";
  77
  78     private final JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
  79     private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
  80     private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
  81     private final UserValidations userValidations = Mockito.mock(UserValidations.class);
  82     private final CapabilitiesOperation capabilitiesOperation = Mockito.mock(CapabilitiesOperation.class);
  83     private final CapabilitiesValidation capabilitiesValidation = Mockito.mock(CapabilitiesValidation.class);
  84
  85     private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
  86     private User user = null;
  87
  88     private final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class);
  89
  90     private CapabilitiesBusinessLogic capabilitiesBusinessLogicMock = new CapabilitiesBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
  91         groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation, capabilityTypeOperation, artifactToscaOperation);
  92
  93     @Before
  94     public void setup() {
  95         MockitoAnnotations.openMocks(this);
  96         ExternalConfiguration.setAppName("catalog-be");
  97
  98         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  99
 100         // User data and management
 101         user = new User();
 102         user.setUserId("jh0003");
 103         user.setFirstName("Jimmi");
 104         user.setLastName("Hendrix");
 105         user.setRole(Role.ADMIN.name());
 106
 107         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 108         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
 109                 .thenReturn(StorageOperationStatus.OK);
 110
 111         //CapabilityOperation
 112         when(capabilitiesValidation.validateCapabilities(anyCollection(), anyObject(), anyBoolean()))
 113                 .thenReturn(Either.left(true));
 114         when(capabilitiesOperation.addCapabilities(anyString(), anyObject()))
 115                 .thenReturn(Either.left(createMockCapabilityListToReturn(
 116                         createCapability("capName", "capDesc", "capType", "source1",
 117                                 "0", "10"))));
 118
 119         when(capabilitiesOperation.updateCapabilities(anyString(), anyObject()))
 120                 .thenReturn(Either.left(createMockCapabilityListToReturn(
 121                         createCapability("capName", "capDesc", "capType", "source1",
 122                                 "0", "10"))));
 123         when(capabilitiesOperation.deleteCapabilities( anyObject(), anyString()))
 124                 .thenReturn(StorageOperationStatus.OK);
 125         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 126
 127         capabilitiesBusinessLogicMock = new CapabilitiesBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 128             groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation,
 129             capabilityTypeOperation, artifactToscaOperation);
 130         capabilitiesBusinessLogicMock.setComponentsUtils(componentsUtils);
 131         capabilitiesBusinessLogicMock.setUserAdmin(mockUserAdmin);
 132         capabilitiesBusinessLogicMock.setGraphLockOperation(graphLockOperation);
 133         capabilitiesBusinessLogicMock.setJanusGraphDao(mockJanusGraphDao);
 134         capabilitiesBusinessLogicMock.setToscaOperationFacade(toscaOperationFacade);
 135         capabilitiesBusinessLogicMock.setUserValidations(userValidations);
 136         capabilitiesBusinessLogicMock.setCapabilitiesOperation(capabilitiesOperation);
 137         capabilitiesBusinessLogicMock.setCapabilitiesValidation(capabilitiesValidation);
 138     }
 139
 140     @Test
 141     public void shouldPassCreateCapabilitiesFirstTimeInComponentForHappyScenario(){
 142         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 143                 createCapability("capName", "capDesc", "capType", "source1",
 144                         "0", "10"));
 145         Resource resource = createComponent(false);
 146         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 147         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 148         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 149                 .thenReturn(Either.left(resource));
 150         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 151                 .createCapabilities(componentId, capabilityDefinitions, user,
 152                         "createCapabilities", true);
 153         Assert.assertTrue(capabilities.isLeft());
 154         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 155                 capabilityDefinition.getName().equals("capName")));
 156     }
 157
 158     @Test
 159     public void shouldPassCreateCapabilitiesForHappyScenario(){
 160         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 161                 createCapability("capName2", "capDesc", "capType", "source1",
 162                         "0", "10"));
 163         Resource resource = createComponent(true);
 164         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 165         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 166         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 167                 .thenReturn(Either.left(resource));
 168         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 169                 .createCapabilities(componentId, capabilityDefinitions, user,
 170                         "createCapabilities", false);
 171
 172         Assert.assertTrue(capabilities.isLeft());
 173         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 174                 capabilityDefinition.getName().equals("capName2")));
 175     }
 176
 177     @Test
 178     public void shouldFailCreateCapabilitiesWhenOperationFailedInJanusGraph(){
 179         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 180                 createCapability("capName2", "capDesc", "capType", "source1",
 181                         "0", "10"));
 182         Resource resource = createComponent(true);
 183         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 184         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 185         when(capabilitiesOperation.addCapabilities(anyString(), anyObject()))
 186                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 187         when(capabilitiesOperation.updateCapabilities(anyString(), anyObject()))
 188                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 189         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 190                 .thenReturn(Either.left(resource));
 191         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 192                 .createCapabilities(componentId, capabilityDefinitions, user,
 193                         "createCapabilities", true);
 194
 195         Assert.assertTrue(capabilities.isRight());
 196     }
 197     @Test
 198     public void shouldPassUpdateCapabilitiesForHappyScenario(){
 199
 200         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 201                 createCapability("capName", "capDesc updated", "capType", "source1",
 202                         "6", "11"));
 203         Resource resource = createComponent(true);
 204         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 205         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 206         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 207                 .thenReturn(Either.left(resource));
 208         when(toscaOperationFacade.getParentComponents(anyString()))
 209                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 210         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 211                 .updateCapabilities(componentId, capabilityDefinitions, user
 212                         , "updateCapabilities", true);
 213         Assert.assertTrue(capabilities.isLeft());
 214         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 215                 capabilityDefinition.getMaxOccurrences().equals("11")));
 216     }
 217
 218     @Test
 219     public void shouldPassUpdateCapabilityTypeUpdateWhenTypeIsNotAvailable(){
 220
 221         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 222                 createCapability("capName", "capDesc updated", "capTypeUpdate", "source1",
 223                         "6", "11"));
 224         Resource resource = createComponent(true);
 225         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 226         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 227         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 228                 .thenReturn(Either.left(resource));
 229         when(toscaOperationFacade.getParentComponents(anyString()))
 230                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 231         when((capabilitiesOperation.deleteCapabilityProperties(any(Component.class), anyString())))
 232                 .thenReturn(StorageOperationStatus.OK);
 233         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 234                 .updateCapabilities(componentId, capabilityDefinitions, user,
 235                         "updateCapabilities",true);
 236         Assert.assertTrue(capabilities.isLeft());
 237         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 238                 capabilityDefinition.getMaxOccurrences().equals("11")));
 239     }
 240
 241     @Test
 242     public void shouldPassUpdateCapabilityTypeUpdateWhenTypeIsAvailable(){
 243
 244         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 245                 createCapability("capName", "capDesc updated", "capTypeUpdate1", "source1",
 246                         "6", "11"));
 247         Resource resource = createComponent(true);
 248         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 249
 250         CapabilityDefinition capability = createCapability("capName", "capDesc", "capTypeUpdate1",
 251                 "source1", "0", "10");
 252         capability.setUniqueId("unique2");
 253         List<CapabilityDefinition> capabilityDefinitions1 = createMockCapabilityListToReturn(capability);
 254         Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
 255         capabilityMap.put("capTypeUpdate1", capabilityDefinitions1);
 256         resource.getCapabilities().putAll(capabilityMap);
 257
 258         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 259         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 260                 .thenReturn(Either.left(resource));
 261         when(toscaOperationFacade.getParentComponents(anyString()))
 262                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 263         when((capabilitiesOperation.deleteCapabilityProperties(any(Component.class), anyString())))
 264                 .thenReturn(StorageOperationStatus.OK);
 265         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 266                 .updateCapabilities(componentId, capabilityDefinitions, user,
 267                         "updateCapabilities",true);
 268         Assert.assertTrue(capabilities.isLeft());
 269         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 270                 capabilityDefinition.getMaxOccurrences().equals("11")));
 271     }
 272
 273     @Test
 274     public void shouldFailUpdateCapabilitiesWhenOperationFailedInJanusGraph(){
 275         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 276                 createCapability("capName2", "capDesc", "capType", "source1",
 277                         "0", "10"));
 278         Resource resource = createComponent(true);
 279         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 280         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 281         when(capabilitiesOperation.addCapabilities(anyString(), anyObject()))
 282                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 283         when(capabilitiesOperation.updateCapabilities(anyString(), anyObject()))
 284                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 285         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 286                 .thenReturn(Either.left(resource));
 287         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 288                 .updateCapabilities(componentId, capabilityDefinitions, user,
 289                         "updateCapabilities", true);
 290
 291         Assert.assertTrue(capabilities.isRight());
 292     }
 293
 294     @Test
 295     public void shouldPassDeleteCapabilitiesForHappyScenario(){
 296         Resource resource = createComponent(true);
 297         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 298         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 299         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 300                 .thenReturn(Either.left(resource));
 301         when(toscaOperationFacade.getParentComponents(anyString()))
 302                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 303         when((capabilitiesOperation.deleteCapabilityProperties(any(Component.class), anyString())))
 304                 .thenReturn(StorageOperationStatus.OK);
 305         Either<CapabilityDefinition, ResponseFormat> deleteCapabilityEither =
 306                 capabilitiesBusinessLogicMock.deleteCapability(componentId, capabilityId, user, true);
 307         Assert.assertTrue(deleteCapabilityEither.isLeft());
 308
 309     }
 310
 311     @Test
 312     public void shouldFailDeleteCapabilitiesWhenOperationFailedInJanusGraph(){
 313         Resource resource = createComponent(true);
 314         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 315         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 316         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 317                 .thenReturn(Either.left(resource));
 318         when(toscaOperationFacade.getParentComponents(anyString()))
 319                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 320         when(capabilitiesOperation.deleteCapabilities(anyObject(), anyString()))
 321                 .thenReturn(StorageOperationStatus.GENERAL_ERROR);
 322         Either<CapabilityDefinition, ResponseFormat> deleteCapabilityEither
 323                 = capabilitiesBusinessLogicMock.deleteCapability(componentId, capabilityId, user, true);
 324         Assert.assertTrue(deleteCapabilityEither.isRight());
 325     }
 326
 327     @Test
 328     public void shouldFailDeleteCapabilitiesWhenCapabilityUsedInServiceComposition(){
 329         Resource resource = createComponent(true);
 330         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 331         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 332         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 333                 .thenReturn(Either.left(resource));
 334         when(toscaOperationFacade.getParentComponents(anyString()))
 335                 .thenReturn(Either.left(Collections.singletonList(createParentService())));
 336         Either<CapabilityDefinition, ResponseFormat> deleteCapabilityEither
 337                 = capabilitiesBusinessLogicMock.deleteCapability(componentId, capabilityId, user, true);
 338         Assert.assertTrue(deleteCapabilityEither.isRight());
 339     }
 340
 341     @Test
 342     public void shouldPassGetCapabilitiesForHappyScenario(){
 343         Resource resource = createComponent(true);
 344         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 345         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 346         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 347                 .thenReturn(Either.left(resource));
 348         when(toscaOperationFacade.getParentComponents(anyString()))
 349                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 350         Either<CapabilityDefinition, ResponseFormat> getCapabilityEither
 351                 = capabilitiesBusinessLogicMock.getCapability(componentId, capabilityId, user, true);
 352         Assert.assertTrue(getCapabilityEither.isLeft());
 353
 354     }
 355
 356     @Test
 357     public void shouldFailGetCapabilitiesWhenCapabilityNotExist(){
 358         Resource resource = createComponent(true);
 359         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 360         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 361         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 362                 .thenReturn(Either.left(resource));
 363         when(toscaOperationFacade.getParentComponents(anyString()))
 364                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 365         Either<CapabilityDefinition, ResponseFormat> getCapabilityEither
 366                 = capabilitiesBusinessLogicMock.getCapability(componentId, "capId1", user, true);
 367         Assert.assertTrue(getCapabilityEither.isRight());
 368
 369     }
 370
 371     private ComponentInstanceProperty createCIP(String type, String name) {
 372         ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
 373         instanceProperty.setType(type);
 374         instanceProperty.setName(name);
 375         instanceProperty.setDescription("prop_description");
 376         instanceProperty.setParentUniqueId(capabilityId);
 377         instanceProperty.setSchema(new SchemaDefinition());
 378         return instanceProperty;
 379     }
 380
 381     @Test
 382     public void shouldPassCreateCapabilitiesWithPropertiesForHappyScenario(){
 383         CapabilityDefinition capability = createCapability("capName", "capDesc", "capType", "source1",
 384                 "0", "10");
 385         capability.setProperties(Collections.singletonList(createCIP("name", "type")));
 386         List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(capability);
 387         Resource resource = createComponent(false);
 388         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 389         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 390         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 391                 .thenReturn(Either.left(resource));
 392         when(capabilitiesOperation.createOrUpdateCapabilityProperties(anyString(), any())).thenReturn(StorageOperationStatus.OK);
 393         Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
 394                 .createCapabilities(componentId, capabilityDefinitions, user,
 395                         "createCapabilities", true);
 396         Assert.assertTrue(capabilities.isLeft());
 397         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 398                 capabilityDefinition.getName().equals("capName")));
 399         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 400                 capabilityDefinition.getProperties().size() == 1));
 401     }
 402
 403     private Resource createComponent(boolean needCapability) {
 404         Resource resource = new Resource();
 405         resource.setName("Resource1");
 406         resource.addCategory("Network Layer 2-3", "Router");
 407         resource.setDescription("My short description");
 408         List<String> tgs = new ArrayList<>();
 409         tgs.add("test");
 410         tgs.add(resource.getName());
 411         resource.setTags(tgs);
 412
 413         if(needCapability) {
 414             List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
 415                     createCapability("capName", "capDesc", "capType", "source1",
 416                             "0", "10"));
 417             Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
 418             capabilityMap.put("capType", capabilityDefinitions);
 419             resource.setCapabilities(capabilityMap);
 420         }
 421         resource.setName(resource.getName());
 422         resource.setVersion("0.1");
 423         resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 424         resource.setCreatorUserId(user.getUserId());
 425         resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 426         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 427         return resource;
 428     }
 429
 430     private List<CapabilityDefinition> createMockCapabilityListToReturn(CapabilityDefinition capabilityDefinition) {
 431         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 432         capabilityDefinitions.add(capabilityDefinition);
 433         return capabilityDefinitions;
 434     }
 435
 436     private void validateUserRoles(Role... roles) {
 437         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
 438     }
 439
 440     private CapabilityDefinition createCapability(String name, String description, String type,
 441                                                   String validSourceTypes, String minOccurrences,
 442                                                   String maxOccurrences) {
 443         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 444         capabilityDefinition.setName(name);
 445         capabilityDefinition.setDescription(description);
 446         capabilityDefinition.setType(type);
 447         capabilityDefinition.setValidSourceTypes(Collections.singletonList(validSourceTypes));
 448         capabilityDefinition.setMaxOccurrences(maxOccurrences);
 449         capabilityDefinition.setMinOccurrences(minOccurrences);
 450         capabilityDefinition.setUniqueId(capabilityId);
 451         return capabilityDefinition;
 452     }
 453
 454     private Service createParentService() {
 455         Service service = new Service();
 456         service.setUniqueId("serviceUniqueId");
 457
 458         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 459         RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
 460         relationDef.setFromNode("fromNode");
 461         relationDef.setToNode("toNode");
 462
 463         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 464         CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
 465
 466         RelationshipInfo relation = new RelationshipInfo();
 467         relation.setCapabilityUid(capabilityId);
 468         relation.setRequirementUid("reqUniqueId1");
 469         capabilityRequirementRelationship.setRelation(relation);
 470
 471         relationships.add(capabilityRequirementRelationship);
 472         relationDef.setRelationships(relationships);
 473         resourceInstancesRelations.add(relationDef);
 474
 475         service.setComponentInstancesRelations(resourceInstancesRelations);
 476
 477         return service;
 478     }
 479
 480 }