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