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