test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/api/ComponentInstanceBaseTest.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.ci.tests.api;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertNotNull;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import java.io.IOException;
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.HashMap;
  31 import java.util.HashSet;
  32 import java.util.LinkedHashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Map.Entry;
  36 import java.util.function.Function;
  37 import java.util.Set;
  38 import java.util.stream.Collectors;
  39
  40 import org.apache.commons.lang3.tuple.ImmutablePair;
  41 import org.junit.rules.TestName;
  42 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  43 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  44 import org.openecomp.sdc.be.model.CapReqDef;
  45 import org.openecomp.sdc.be.model.CapabilityDefinition;
  46 import org.openecomp.sdc.be.model.Component;
  47 import org.openecomp.sdc.be.model.ComponentInstance;
  48 import org.openecomp.sdc.be.model.Product;
  49 import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
  50 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  51 import org.openecomp.sdc.be.model.RequirementDefinition;
  52 import org.openecomp.sdc.be.model.Resource;
  53 import org.openecomp.sdc.be.model.Service;
  54 import org.openecomp.sdc.be.model.User;
  55 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  56 import org.openecomp.sdc.ci.tests.datatypes.ComponentReqDetails;
  57 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
  58 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  59 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  60 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  61 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  62 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  63 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  64 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  65 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  66 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  67 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  68 import org.openecomp.sdc.ci.tests.utils.rest.ComponentRestUtils;
  69 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
  70 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  71 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  72 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  73 import org.testng.Assert;
  74
  75 public class ComponentInstanceBaseTest extends ComponentBaseTest {
  76         public static final String acceptHeaderData = "application/json";
  77         // Req/cap of container component
  78         protected Map<String, List<CapabilityDefinition>> expectedContainerCapabilities;
  79         protected Map<String, List<RequirementDefinition>> expectedContainerRequirements;
  80         protected Map<String, Map<String, List<RequirementDefinition>>> removedRequirements;
  81         protected Map<String, ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>>> expectedContInstReqCap;
  82
  83         protected User sdncPsDetails1;
  84         protected User sdncPsDetails2;
  85         protected User sdncPmDetails1;
  86         protected User sdncPmDetails2;
  87         protected User sdncDesignerDetails;
  88         protected User sdncAdminDetails;
  89         protected User sdncTesterDetails;
  90         protected ResourceReqDetails resourceDetailsVFC_01;
  91         protected ResourceReqDetails resourceDetailsVFC_02;
  92         protected ResourceReqDetails resourceDetailsVF_01;
  93         protected ResourceReqDetails resourceDetailsVF_02;
  94         protected ResourceReqDetails resourceDetailsCP_01;
  95         protected ResourceReqDetails resourceDetailsCP_02;
  96         protected ResourceReqDetails resourceDetailsVL_01;
  97         protected ResourceReqDetails resourceDetailsVL_02;
  98         protected ServiceReqDetails serviceDetails_01;
  99         protected ServiceReqDetails serviceDetails_02;
 100         protected ServiceReqDetails serviceDetails_03;
 101         protected ProductReqDetails productDetails_01;
 102         protected ProductReqDetails productDetails_02;
 103
 104         public void init() {
 105                 // Req/caps of inner componentInstances
 106                 expectedContainerCapabilities = new LinkedHashMap<String, List<CapabilityDefinition>>();
 107                 expectedContainerRequirements = new LinkedHashMap<String, List<RequirementDefinition>>();
 108                 removedRequirements = new HashMap<>();
 109                 expectedContInstReqCap = new HashMap<>();
 110
 111                 sdncPsDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1);
 112                 sdncPsDetails2 = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST2);
 113                 sdncPmDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
 114                 sdncPmDetails2 = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER2);
 115                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 116                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 117                 sdncTesterDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 118                 resourceDetailsVFC_01 = ElementFactory.getDefaultResourceByType("ciVFC100", NormativeTypesEnum.SOFTWARE_COMPONENT, ResourceCategoryEnum.GENERIC_DATABASE, sdncDesignerDetails.getUserId(), ResourceTypeEnum.VFC.toString()); // resourceType = VFC
 119                 resourceDetailsVFC_02 = ElementFactory.getDefaultResourceByType("ciVFC200", NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(), ResourceTypeEnum.VFC.toString());
 120                 resourceDetailsVF_01 = ElementFactory.getDefaultResourceByType("ciVF100", NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(), ResourceTypeEnum.VF.toString());
 121                 resourceDetailsVF_02 = ElementFactory.getDefaultResourceByType("ciVF200", NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(), ResourceTypeEnum.VF.toString());
 122                 resourceDetailsCP_01 = ElementFactory.getDefaultResourceByType("ciCP100", NormativeTypesEnum.PORT, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, sdncDesignerDetails.getUserId(), ResourceTypeEnum.CP.toString());
 123                 resourceDetailsCP_02 = ElementFactory.getDefaultResourceByType("ciCP200", NormativeTypesEnum.PORT, ResourceCategoryEnum.GENERIC_DATABASE, sdncDesignerDetails.getUserId(), ResourceTypeEnum.CP.toString());
 124                 resourceDetailsVL_01 = ElementFactory.getDefaultResourceByType("ciVL100", NormativeTypesEnum.NETWORK, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, sdncDesignerDetails.getUserId(), ResourceTypeEnum.VL.toString());
 125                 resourceDetailsVL_02 = ElementFactory.getDefaultResourceByType("ciVL200", NormativeTypesEnum.NETWORK, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, sdncDesignerDetails.getUserId(), ResourceTypeEnum.VL.toString());
 126                 serviceDetails_01 = ElementFactory.getDefaultService("ciNewtestservice1", ServiceCategoriesEnum.MOBILITY, sdncDesignerDetails.getUserId());
 127                 serviceDetails_02 = ElementFactory.getDefaultService("ciNewtestservice2", ServiceCategoriesEnum.MOBILITY, sdncDesignerDetails.getUserId());
 128                 serviceDetails_03 = ElementFactory.getDefaultService("ciNewtestservice3", ServiceCategoriesEnum.MOBILITY, sdncDesignerDetails.getUserId());
 129                 productDetails_01 = ElementFactory.getDefaultProduct("ciProduct01");
 130                 productDetails_02 = ElementFactory.getDefaultProduct("ciProduct02");
 131         }
 132
 133         public ComponentInstanceBaseTest(TestName testName, String className) {
 134                 super(testName, className);
 135         }
 136
 137         public void verifyVFReqCap(String componentId) throws Exception {
 138                 RestResponse restResponse = ResourceRestUtils.getResource(componentId);
 139                 Resource resource = ResponseParser.parseToObject(restResponse.getResponse(), Resource.class);
 140                 verifyReqCap(resource);
 141         }
 142
 143         public void verifyServiceReqCap(String componentId) throws Exception {
 144                 RestResponse restResponse = ServiceRestUtils.getService(componentId, sdncDesignerDetails);
 145                 Service service = ResponseParser.parseToObject(restResponse.getResponse(), Service.class);
 146                 verifyReqCap(service);
 147         }
 148
 149         public void verifyProductReqCap(String componentId) throws Exception {
 150                 RestResponse restResponse = ProductRestUtils.getProduct(componentId, sdncPsDetails1.getUserId());
 151                 Product product = ResponseParser.parseToObject(restResponse.getResponse(), Product.class);
 152                 verifyReqCap(product);
 153         }
 154
 155         public void verifyReqCap(Component actualComponent) {
 156                 verifyContainerReqCap(actualComponent);
 157                 verifyCompInstReqCap(actualComponent);
 158         }
 159
 160         public RestResponse changeServiceInstanceVersion(String componentUniqueId, String serviceInstanceToReplaceUniqueId, String serviceUniqueId, User sdncModifierDetails, ComponentTypeEnum componentType, boolean isHighestLevel) throws Exception {
 161                 RestResponse changeResourceInstanceVersion = ProductRestUtils.changeServiceInstanceVersion(componentUniqueId, serviceInstanceToReplaceUniqueId, serviceUniqueId, sdncModifierDetails, componentType);
 162                 if (changeResourceInstanceVersion.getErrorCode().equals(BaseRestUtils.STATUS_CODE_SUCCESS) && isHighestLevel) {
 163                         /*
 164                          * // Add RI Capabilities and Requirements to expected MAP --> expectedVfCapabilities and expectedVfRequirements
 165                          *
 166                          * ComponentInstance componentInstance = ResponseParser.parseToObjectUsingMapper( changeResourceInstanceVersion.getResponse(), ComponentInstance.class); addCompInstReqCapToExpected(componentInstance, componentType);
 167                          */
 168                 }
 169                 return changeResourceInstanceVersion;
 170         }
 171
 172         protected void updateExpectedReqCapAfterChangeLifecycleState(String oldContainerUniqueIdToReplace, String newContainerUniqueId) {
 173
 174                 // Update of container req/cap
 175
 176                 Set<String> compInstKeysToChange = new HashSet<>();
 177
 178                 for (String expKey : expectedContainerCapabilities.keySet()) {
 179                         List<CapabilityDefinition> expCapList = expectedContainerCapabilities.get(expKey);
 180                         for (CapabilityDefinition cap : expCapList) {
 181                                 String ownerId = cap.getOwnerId();
 182
 183                                 if (ownerId.contains(oldContainerUniqueIdToReplace)) {
 184                                         compInstKeysToChange.add(ownerId);
 185                                         cap.setOwnerId(cap.getOwnerId().replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
 186                                 }
 187                         }
 188                 }
 189
 190                 for (String expKey : expectedContainerRequirements.keySet()) {
 191                         List<RequirementDefinition> expCapList = expectedContainerRequirements.get(expKey);
 192                         for (RequirementDefinition cap : expCapList) {
 193                                 String ownerId = cap.getOwnerId();
 194                                 if (ownerId.contains(oldContainerUniqueIdToReplace)) {
 195                                         compInstKeysToChange.add(ownerId);
 196                                         cap.setOwnerId(cap.getOwnerId().replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
 197                                 }
 198                         }
 199                 }
 200
 201                 // Update of internal comp instances req/cap
 202                 for (String oldKey : compInstKeysToChange) {
 203                         ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> immutablePair = expectedContInstReqCap.get(oldKey);
 204                         if (immutablePair != null) {
 205                                 expectedContInstReqCap.remove(oldKey);
 206                                 String newKey = oldKey.replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId);
 207                                 expectedContInstReqCap.put(newKey, immutablePair);
 208                         }
 209                 }
 210
 211                 // Update of removed req
 212                 for (String oldKey : compInstKeysToChange) {
 213                         Map<String, List<RequirementDefinition>> map = removedRequirements.get(oldKey);
 214                         if (map != null) {
 215                                 removedRequirements.remove(oldKey);
 216                                 String newKey = oldKey.replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId);
 217                                 Collection<List<RequirementDefinition>> values = map.values();
 218                                 if (values != null) {
 219                                         for (List<RequirementDefinition> list : values) {
 220                                                 for (RequirementDefinition reqDef : list) {
 221                                                         reqDef.setOwnerId(reqDef.getOwnerId().replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
 222                                                 }
 223                                         }
 224                                 }
 225                                 removedRequirements.put(newKey, map);
 226                         }
 227                 }
 228         }
 229
 230         private void verifyCompInstReqCap(Component actualComponent) {
 231                 List<ComponentInstance> componentInstances = actualComponent.getComponentInstances();
 232                 if (componentInstances != null) {
 233                         assertEquals(expectedContInstReqCap.size(), componentInstances.size());
 234                         for (ComponentInstance compInst : componentInstances) {
 235                                 String uniqueId = compInst.getUniqueId();
 236                                 // System.out.println("Verifying req/cap of component instance
 237                                 // "+ uniqueId);
 238                                 Map<String, List<RequirementDefinition>> actualCompInstReq = compInst.getRequirements();
 239                                 if (actualCompInstReq == null) {
 240                                         actualCompInstReq = new HashMap<>();
 241                                 }
 242                                 Map<String, List<CapabilityDefinition>> actualCompInstCap = compInst.getCapabilities();
 243                                 if (actualCompInstCap == null) {
 244                                         actualCompInstCap = new HashMap<>();
 245                                 }
 246                                 ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> expReqCap = expectedContInstReqCap.get(uniqueId);
 247                                 assertNotNull(expReqCap);
 248                                 // System.out.println("expected instance requirements:
 249                                 // "+expReqCap.right);
 250                                 // System.out.println("expected instance capabilities:
 251                                 // "+expReqCap.left);
 252                                 // System.out.println("actual instance requirements:
 253                                 // "+actualCompInstReq);
 254                                 // System.out.println("actual instance capabilities:
 255                                 // "+actualCompInstCap);
 256
 257                                 // REQ comparison
 258                                 compareReqCapMaps(expReqCap.right, actualCompInstReq);
 259
 260                                 // CAP comparison
 261                                 compareReqCapMaps(expReqCap.left, actualCompInstCap);
 262                         }
 263
 264                 } else {
 265                         assertTrue(expectedContInstReqCap.isEmpty());
 266                 }
 267         }
 268
 269         private void verifyContainerReqCap(Component actualComponent) {
 270                 Map<String, List<RequirementDefinition>> actualContainerRequirements = actualComponent.getRequirements();
 271                 if (actualContainerRequirements == null) {
 272                         actualContainerRequirements = new HashMap<>();
 273                 }
 274                 Map<String, List<CapabilityDefinition>> actualContainerCapabilities = actualComponent.getCapabilities();
 275                 if (actualContainerCapabilities == null) {
 276                         actualContainerCapabilities = new HashMap<>();
 277                 }
 278                 // System.out.println("Verifying req/cap of container component "+
 279                 // actualComponent.getUniqueId());
 280                 // System.out.println("expected container requirements:
 281                 // "+expectedContainerRequirements);
 282                 // System.out.println("expected container capabilities:
 283                 // "+expectedContainerCapabilities);
 284                 // System.out.println("actual container requirements:
 285                 // "+actualContainerRequirements);
 286                 // System.out.println("actual container capabilities:
 287                 // "+actualContainerCapabilities);
 288
 289                 // REQ comparison
 290                 compareReqCapMaps(expectedContainerRequirements, actualContainerRequirements);
 291
 292                 // CAP comparison
 293                 compareReqCapMaps(expectedContainerCapabilities, actualContainerCapabilities);
 294         }
 295
 296         private <T> void compareReqCapMaps(Map<String, List<T>> expectedMap, Map<String, List<T>> actualMap) {
 297                 assertEquals(expectedMap.size(), actualMap.size());
 298                 for (String expKey : expectedMap.keySet()) {
 299                         List<?> expCapList = expectedMap.get(expKey);
 300                         List<?> actCapList = actualMap.get(expKey);
 301                         assertEquals(expCapList.size(), actCapList.size());
 302                         assertEquals(new HashSet<>(expCapList), new HashSet<>(actCapList));
 303                 }
 304         }
 305
 306         public void addCompInstReqCapToExpected(ComponentInstance componentInstance, ComponentTypeEnum containerComponentType) throws Exception {
 307                 String uniqueId = componentInstance.getUniqueId();
 308                 String name = componentInstance.getName();
 309                 String originComponentId = componentInstance.getComponentUid();
 310                 RestResponse getResponse = null;
 311                 ComponentTypeEnum compInstType = getCompInstTypeByContainerType(containerComponentType);
 312                 Component component = null;
 313                 if (compInstType == ComponentTypeEnum.RESOURCE) {
 314                         getResponse = ResourceRestUtils.getResource(sdncDesignerDetails, originComponentId);
 315                         ResourceRestUtils.checkSuccess(getResponse);
 316                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Resource.class);
 317                 } else if (compInstType == ComponentTypeEnum.SERVICE) {
 318                         getResponse = ServiceRestUtils.getService(originComponentId, sdncDesignerDetails);
 319                         ResourceRestUtils.checkSuccess(getResponse);
 320                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Service.class);
 321                 } else {
 322                         Assert.fail("Unsupported type - " + containerComponentType);
 323                 }
 324
 325                 Map<String, List<RequirementDefinition>> resourceRequirements = component.getRequirements();
 326                 if (resourceRequirements == null) {
 327                         resourceRequirements = new HashMap<>();
 328                 }
 329
 330                 Function<Entry<String, List<RequirementDefinition>>, List<RequirementDefinition>> requirementDefinitionMapper = e -> new ArrayList<>(e.getValue().stream().map(item -> new RequirementDefinition(item)).collect(Collectors.toList()));
 331                 Map<String, List<RequirementDefinition>> reqCopy = resourceRequirements.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), requirementDefinitionMapper));
 332
 333                 Map<String, List<CapabilityDefinition>> resourceCapabilities = component.getCapabilities();
 334                 if (resourceCapabilities == null) {
 335                         resourceCapabilities = new HashMap<>();
 336                 }
 337
 338                 Function<? super Entry<String, List<CapabilityDefinition>>, List<CapabilityDefinition>> capabilityDefinitionMapper = e -> new ArrayList<>(e.getValue().stream().map(item -> new CapabilityDefinition(item)).collect(Collectors.toList()));
 339                 Map<String, List<CapabilityDefinition>> capCopy = resourceCapabilities.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), capabilityDefinitionMapper));
 340
 341                 setupContainerExpectedReqCap(uniqueId, name, resourceRequirements, resourceCapabilities);
 342                 if (component.getComponentType().equals(ComponentTypeEnum.RESOURCE) && ((Resource) component).getResourceType() != ResourceTypeEnum.VF) {
 343                         setupConstInstExpectedReqCap(uniqueId, name, reqCopy, capCopy);
 344                 }
 345
 346                 // adding entry for expected componentInstance
 347                 ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> compInstReqCapPair = new ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>>(capCopy, reqCopy);
 348                 expectedContInstReqCap.put(uniqueId, compInstReqCapPair);
 349         }
 350
 351         private void setupContainerExpectedReqCap(String uniqueId, String name, Map<String, List<RequirementDefinition>> componentRequirements, Map<String, List<CapabilityDefinition>> componentCapabilities) {
 352                 for (Entry<String, List<RequirementDefinition>> resReq : componentRequirements.entrySet()) {
 353                         List<RequirementDefinition> reqListToAdd = resReq.getValue();
 354                         for (RequirementDefinition requirementDefinition : reqListToAdd) {
 355                                 requirementDefinition.setOwnerId(uniqueId);
 356                                 requirementDefinition.setOwnerName(name);
 357                         }
 358                         List<RequirementDefinition> expectedReqList = expectedContainerRequirements.get(resReq.getKey());
 359                         if (expectedReqList == null) {
 360                                 expectedReqList = reqListToAdd;
 361                         } else {
 362                                 expectedReqList.addAll(reqListToAdd);
 363                         }
 364                         expectedContainerRequirements.put(resReq.getKey(), expectedReqList);
 365                 }
 366
 367                 for (Entry<String, List<CapabilityDefinition>> resCap : componentCapabilities.entrySet()) {
 368                         List<CapabilityDefinition> capListToAdd = resCap.getValue();
 369                         for (CapabilityDefinition capDefinition : capListToAdd) {
 370                                 capDefinition.setOwnerId(uniqueId);
 371                                 capDefinition.setOwnerName(name);
 372                         }
 373                         List<CapabilityDefinition> expectedCapList = expectedContainerCapabilities.get(resCap.getKey());
 374                         if (expectedCapList == null) {
 375                                 expectedCapList = capListToAdd;
 376                         } else {
 377                                 expectedCapList.addAll(capListToAdd);
 378                         }
 379                         expectedContainerCapabilities.put(resCap.getKey(), expectedCapList);
 380                 }
 381         }
 382
 383         private void setupConstInstExpectedReqCap(String uniqueId, String name, Map<String, List<RequirementDefinition>> componentRequirements, Map<String, List<CapabilityDefinition>> componentCapabilities) {
 384                 for (Entry<String, List<RequirementDefinition>> resReq : componentRequirements.entrySet()) {
 385                         List<RequirementDefinition> reqListToAdd = resReq.getValue();
 386                         for (RequirementDefinition requirementDefinition : reqListToAdd) {
 387                                 requirementDefinition.setOwnerId(uniqueId);
 388                                 requirementDefinition.setOwnerName(name);
 389                         }
 390                 }
 391
 392                 for (Entry<String, List<CapabilityDefinition>> resCap : componentCapabilities.entrySet()) {
 393                         List<CapabilityDefinition> capListToAdd = resCap.getValue();
 394                         for (CapabilityDefinition capDefinition : capListToAdd) {
 395                                 capDefinition.setOwnerId(uniqueId);
 396                                 capDefinition.setOwnerName(name);
 397                         }
 398                 }
 399         }
 400
 401         private ComponentTypeEnum getCompInstTypeByContainerType(ComponentTypeEnum componentType) {
 402                 switch (componentType) {
 403                 case RESOURCE:
 404                         return ComponentTypeEnum.RESOURCE;
 405                 case SERVICE:
 406                         return ComponentTypeEnum.RESOURCE;
 407                 case PRODUCT:
 408                         return ComponentTypeEnum.SERVICE;
 409                 default:
 410                         break;
 411                 }
 412                 return null;
 413         }
 414
 415         public void deleteCompInstReqCapFromExpected(String componentInstanceId) {
 416                 List<String> entriesRequirementsToRemove = new ArrayList<>();
 417                 List<String> entriesCapabilitiesToRemove = new ArrayList<>();
 418                 for (Entry<String, List<RequirementDefinition>> reqEntry : expectedContainerRequirements.entrySet()) {
 419                         List<RequirementDefinition> reqList = reqEntry.getValue();
 420                         List<RequirementDefinition> reqListToDelete = new ArrayList<>();
 421                         for (RequirementDefinition requirementDefinition : reqList) {
 422                                 if (requirementDefinition.getOwnerId().equals(componentInstanceId)) {
 423                                         reqListToDelete.add(requirementDefinition);
 424                                 }
 425                         }
 426                         reqList.removeAll(reqListToDelete);
 427                         if (reqList.isEmpty()) {
 428                                 entriesRequirementsToRemove.add(reqEntry.getKey());
 429                         }
 430                 }
 431
 432                 for (String ekey : entriesRequirementsToRemove) {
 433                         expectedContainerRequirements.remove(ekey);
 434                 }
 435
 436                 for (Entry<String, List<CapabilityDefinition>> capEntry : expectedContainerCapabilities.entrySet()) {
 437                         List<CapabilityDefinition> capList = capEntry.getValue();
 438                         List<CapabilityDefinition> capListToDelete = new ArrayList<>();
 439                         for (CapabilityDefinition capabilityDefinition : capList) {
 440                                 if (capabilityDefinition.getOwnerId().equals(componentInstanceId)) {
 441                                         capListToDelete.add(capabilityDefinition);
 442                                 }
 443                         }
 444                         capList.removeAll(capListToDelete);
 445                         if (capList.isEmpty()) {
 446                                 entriesCapabilitiesToRemove.add(capEntry.getKey());
 447                         }
 448                 }
 449                 for (String ekey : entriesCapabilitiesToRemove) {
 450                         expectedContainerCapabilities.remove(ekey);
 451                 }
 452
 453                 expectedContInstReqCap.remove(componentInstanceId);
 454
 455         }
 456
 457         // Automatically updates the expected req/cap of the container
 458         protected RestResponse createAtomicInstanceForVF(ResourceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 459                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.RESOURCE, true);
 460         }
 461
 462         // Automatically updates the expected req/cap of the container
 463         protected RestResponse createAtomicInstanceForService(ServiceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 464                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE, true);
 465         }
 466
 467         // Automatically updates the expected req/cap of the container
 468         protected RestResponse createVFInstance(ServiceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 469                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE, true);
 470         }
 471
 472         // Automatically updates the expected req/cap of the container
 473         protected RestResponse createServiceInstance(ProductReqDetails containerDetails, ServiceReqDetails compInstOriginDetails, User modifier) throws Exception {
 474                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.PRODUCT, true);
 475         }
 476
 477         // Automatically updates the expected req/cap of the container
 478         protected RestResponse deleteAtomicInstanceForVF(String compInstUniqueId, ResourceReqDetails containerDetails, User modifier) throws IOException, Exception {
 479                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.RESOURCE, true);
 480         }
 481
 482         // Automatically updates the expected req/cap of the container
 483         protected RestResponse deleteAtomicInstanceForService(String compInstUniqueId, ServiceReqDetails containerDetails, User modifier) throws IOException, Exception {
 484                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, true);
 485         }
 486
 487         // Automatically updates the expected req/cap of the container
 488         protected RestResponse deleteVFInstance(String compInstUniqueId, ServiceReqDetails containerDetails, User modifier) throws IOException, Exception {
 489                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, true);
 490
 491         }
 492
 493         // Automatically updates the expected req/cap of the container
 494         protected RestResponse deleteServiceInstance(String compInstUniqueId, ProductReqDetails containerDetails, User modifier) throws IOException, Exception {
 495                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.PRODUCT, true);
 496         }
 497
 498         // Setup of lower components - Doesn't affect req/cap of the container (for
 499         // example, setup of VF for testing a Product)
 500         protected RestResponse createAtomicInstanceForVFDuringSetup(ResourceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 501                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.RESOURCE, false);
 502         }
 503
 504         // Setup of lower components - Doesn't affect req/cap of the container (for
 505         // example, setup of VF for testing a Product)
 506         protected RestResponse createAtomicInstanceForServiceDuringSetup(ServiceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 507                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE, false);
 508         }
 509
 510         // Setup of lower components - Doesn't affect req/cap of the container (for
 511         // example, setup of VF for testing a Product)
 512         protected RestResponse createVFInstanceDuringSetup(ServiceReqDetails containerDetails, ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 513                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE, false);
 514         }
 515
 516         // Setup of lower components - Doesn't affect req/cap of the container (for
 517         // example, setup of VF for testing a Product)
 518         protected RestResponse createServiceInstanceDuringSetup(ProductReqDetails containerDetails, ServiceReqDetails compInstOriginDetails, User modifier) throws Exception {
 519                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.PRODUCT, false);
 520         }
 521
 522         // Setup of lower components - Doesn't affect req/cap of the container (for
 523         // example, setup of VF for testing a Product)
 524         protected RestResponse deleteAtomicInstanceForVFDuringSetup(String compInstUniqueId, ResourceReqDetails containerDetails, User modifier) throws IOException, Exception {
 525                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.RESOURCE, false);
 526         }
 527
 528         // Setup of lower components - Doesn't affect req/cap of the container (for
 529         // example, setup of VF for testing a Product)
 530         protected RestResponse deleteAtomicInstanceForServiceDuringSetup(String compInstUniqueId, ServiceReqDetails containerDetails, User modifier) throws IOException, Exception {
 531                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, false);
 532         }
 533
 534         // Setup of lower components - Doesn't affect req/cap of the container (for
 535         // example, setup of VF for testing a Product)
 536         protected RestResponse deleteVFInstanceDuringSetup(String compInstUniqueId, ServiceReqDetails containerDetails, User modifier) throws IOException, Exception {
 537                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, false);
 538
 539         }
 540
 541         // Setup of lower components - Doesn't affect req/cap of the container (for
 542         // example, setup of VF for testing a Product)
 543         protected RestResponse deleteServiceInstanceDuringSetup(String compInstUniqueId, ProductReqDetails containerDetails, User modifier) throws IOException, Exception {
 544                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.PRODUCT, false);
 545         }
 546
 547         protected Component getComponentAndValidateRIs(ComponentReqDetails componentDetails, int numberOfRIs, int numberOfRelations) throws IOException, Exception {
 548
 549                 RestResponse getResponse = null;
 550                 Component component = null;
 551                 if (componentDetails instanceof ResourceReqDetails) {
 552                         getResponse = ResourceRestUtils.getResource(sdncAdminDetails, componentDetails.getUniqueId());
 553                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Resource.class);
 554                 } else if (componentDetails instanceof ServiceReqDetails) {
 555                         getResponse = ServiceRestUtils.getService((ServiceReqDetails) componentDetails, sdncAdminDetails);
 556                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Service.class);
 557                 } else if (componentDetails instanceof ProductReqDetails) {
 558                         getResponse = ProductRestUtils.getProduct(componentDetails.getUniqueId(), sdncAdminDetails.getUserId());
 559                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Product.class);
 560                 } else {
 561                         Assert.fail("Unsupported type of componentDetails - " + componentDetails.getClass().getSimpleName());
 562                 }
 563                 ResourceRestUtils.checkSuccess(getResponse);
 564                 int numberOfActualRIs = component.getComponentInstances() != null ? component.getComponentInstances().size() : 0;
 565                 int numberOfActualRelations = component.getComponentInstancesRelations() != null ? component.getComponentInstancesRelations().size() : 0;
 566                 assertEquals("Check number of RIs meet the expected number", numberOfRIs, numberOfActualRIs);
 567                 assertEquals("Check number of RI relations meet the expected number", numberOfRelations, numberOfActualRelations);
 568                 verifyReqCap(component);
 569
 570                 return component;
 571         }
 572
 573         protected void getComponentAndValidateRIsAfterChangeLifecycleState(String oldComponentUniqueIdToReplace, ComponentReqDetails componentDetails, int numOfRIs, int numOfRelations) throws IOException, Exception {
 574                 updateExpectedReqCapAfterChangeLifecycleState(oldComponentUniqueIdToReplace, componentDetails.getUniqueId());
 575                 getComponentAndValidateRIs(componentDetails, numOfRIs, numOfRelations);
 576         }
 577
 578         private RestResponse createComponentInstance(ComponentReqDetails containerDetails, ComponentReqDetails compInstOriginDetails, User modifier, ComponentTypeEnum containerComponentTypeEnum, boolean isHighestLevel) throws IOException, Exception {
 579                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory.getComponentResourceInstance(compInstOriginDetails);
 580                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(resourceInstanceReqDetails, modifier, containerDetails.getUniqueId(), containerComponentTypeEnum);
 581                 if (createResourceInstanceResponse.getErrorCode().equals(BaseRestUtils.STATUS_CODE_CREATED) && isHighestLevel) {
 582                         // Add RI Capabilities and Requirements to expected MAP -->
 583                         // expectedVfCapabilities and expectedVfRequirements
 584                         ComponentInstance componentInstance = ResponseParser.parseToObjectUsingMapper(createResourceInstanceResponse.getResponse(), ComponentInstance.class);
 585                         addCompInstReqCapToExpected(componentInstance, containerComponentTypeEnum);
 586                 }
 587                 return createResourceInstanceResponse;
 588         }
 589
 590         private RestResponse deleteComponentInstance(String compInstUniqueId, ComponentReqDetails containerDetails, User modifier, ComponentTypeEnum componentTypeEnum, boolean isHighestLevel) throws Exception {
 591                 RestResponse deleteResourceInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(modifier, containerDetails.getUniqueId(), compInstUniqueId, componentTypeEnum);
 592                 if (deleteResourceInstanceResponse.getErrorCode().equals(BaseRestUtils.STATUS_CODE_DELETE) && isHighestLevel) {
 593                         deleteCompInstReqCapFromExpected(compInstUniqueId);
 594                 }
 595                 return deleteResourceInstanceResponse;
 596         }
 597
 598         // Create Atomic resource ( VFC/CP/VL)
 599         protected void createAtomicResource(ResourceReqDetails resourceDetails) throws Exception {
 600                 RestResponse createResourceResponse = ResourceRestUtils.createResource(resourceDetails, sdncDesignerDetails);
 601                 ResourceRestUtils.checkCreateResponse(createResourceResponse);
 602
 603         }
 604
 605         protected void createVF(ResourceReqDetails resourceDetails) throws Exception {
 606                 createVF(resourceDetails, sdncDesignerDetails);
 607
 608         }
 609
 610         protected void createVF(ResourceReqDetails resourceDetails, User sdncModifier) throws Exception {
 611                 RestResponse createVfResponse = ResourceRestUtils.createResource(resourceDetails, sdncModifier);
 612                 ResourceRestUtils.checkCreateResponse(createVfResponse);
 613         }
 614
 615         protected void createService(ServiceReqDetails serviceDetails) throws Exception {
 616                 createService(serviceDetails, sdncDesignerDetails);
 617         }
 618
 619         protected void createService(ServiceReqDetails serviceDetails, User sdncModifier) throws Exception {
 620                 RestResponse createServiceResponse = ServiceRestUtils.createService(serviceDetails, sdncModifier);
 621                 ResourceRestUtils.checkCreateResponse(createServiceResponse);
 622         }
 623
 624         protected void createProduct(ProductReqDetails productDetails) throws Exception {
 625                 createProduct(productDetails, sdncPmDetails1);
 626         }
 627
 628         protected void createProduct(ProductReqDetails productDetails, User sdncModifier) throws Exception {
 629                 RestResponse createProductResponse = ProductRestUtils.createProduct(productDetails, sdncModifier);
 630                 ResourceRestUtils.checkCreateResponse(createProductResponse);
 631         }
 632
 633         protected RestResponse associateComponentInstancesForService(RequirementCapabilityRelDef requirementDef, ComponentReqDetails containerDetails, User user) throws IOException {
 634
 635                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, user, containerDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
 636                 ResourceRestUtils.checkSuccess(associateInstances);
 637                 deleteAssociatedFromExpected(requirementDef);
 638
 639                 return associateInstances;
 640         }
 641
 642         private void deleteAssociatedFromExpected(RequirementCapabilityRelDef requirementDef) {
 643                 // removing from requirements
 644                 RequirementAndRelationshipPair relationship = requirementDef.getRelationships().get(0);
 645                 String type = relationship.getRelationship().getType();
 646                 String fromId = requirementDef.getFromNode();
 647                 List<RequirementDefinition> reqList = expectedContainerRequirements.get(type);
 648                 List<CapabilityDefinition> capList = expectedContainerCapabilities.get(type);
 649                 RequirementDefinition toDelete = null;
 650                 if (reqList != null) {
 651                         for (RequirementDefinition reqDef : reqList) {
 652                                 if (reqDef.getOwnerId().equals(fromId)) {
 653                                         toDelete = reqDef;
 654                                 }
 655                         }
 656                         if (toDelete != null) {
 657                                 reqList.remove(toDelete);
 658                                 if (reqList.isEmpty()) {
 659                                         expectedContainerRequirements.remove(type);
 660                                 }
 661                                 String ownerId = toDelete.getOwnerId();
 662                                 Map<String, List<RequirementDefinition>> map = removedRequirements.get(ownerId);
 663                                 if (map == null) {
 664                                         map = new HashMap<>();
 665                                         removedRequirements.put(ownerId, map);
 666                                 }
 667                                 List<RequirementDefinition> list = map.get(type);
 668                                 if (list == null) {
 669                                         list = new ArrayList<>();
 670                                         map.put(type, list);
 671                                 }
 672                                 list.add(toDelete);
 673                         }
 674                 }
 675
 676                 for (CapabilityDefinition capabilityDefinition : capList) {
 677                         if (capabilityDefinition.getType().equals(type)) {
 678                                 int minOccurrences = Integer.parseInt(capabilityDefinition.getMinOccurrences()) - 1;
 679                                 if (minOccurrences < 0)
 680                                         minOccurrences = 0;
 681                                 String minOccurrencesString = Integer.toString(minOccurrences);
 682                                 capabilityDefinition.setMinOccurrences(minOccurrencesString);
 683                                 if (!capabilityDefinition.getMaxOccurrences().equals("UNBOUNDED")) {
 684                                         int maxOccurrences = Integer.parseInt(capabilityDefinition.getMaxOccurrences()) - 1;
 685                                         if (maxOccurrences < 0)
 686                                                 maxOccurrences = 0;
 687                                         String maxOccurrencesString = Integer.toString(maxOccurrences);
 688                                         capabilityDefinition.setMaxOccurrences(maxOccurrencesString);
 689                                 }
 690                         }
 691                 }
 692                 expectedContainerCapabilities.put(type, capList);
 693         }
 694
 695         protected void dissociateComponentInstancesForService(RequirementCapabilityRelDef requirementDef, ComponentReqDetails containerDetails, User user) throws IOException {
 696
 697                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, user, containerDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
 698                 ResourceRestUtils.checkSuccess(dissociateInstances);
 699                 addDissociatedToExpected(requirementDef);
 700         }
 701
 702         protected void fulfillCpRequirement(ComponentReqDetails component, String cpCompInstId, String cpReqFulfillerCompInstId, String cpReqFulfillerOwnerId, User user, ComponentTypeEnum containerCompType) throws IOException {
 703                 // Fulfilling cp's "binding" requirement - US626240
 704                 String requirementName = "binding";
 705                 String capType = "tosca.capabilities.network.Bindable";
 706                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(user, component);
 707                 ResourceRestUtils.checkSuccess(getResourceResponse);
 708                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 709                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 710                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 711                 RequirementCapabilityRelDef reqCapRelation = ElementFactory.getReqCapRelation(cpCompInstId, cpReqFulfillerCompInstId, cpCompInstId, cpReqFulfillerOwnerId, capType, requirementName, capList, reqList);
 712                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(reqCapRelation, user, component.getUniqueId(), containerCompType);
 713                 ResourceRestUtils.checkSuccess(associateInstances);
 714         }
 715
 716         protected void consumeVlCapability(ComponentReqDetails component, String vlCapConsumerCompInstId, String vlCompInstId, String vlCapConsumerOwnerId, User user, ComponentTypeEnum containerCompType) throws IOException {
 717                 // Consuming vl's "link" capability - US626240
 718                 String requirementName = "link";
 719                 String capType = "tosca.capabilities.network.Linkable";
 720                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(user, component);
 721                 ResourceRestUtils.checkSuccess(getResourceResponse);
 722                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 723                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 724                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 725                 RequirementCapabilityRelDef reqCapRelation = ElementFactory.getReqCapRelation(vlCapConsumerCompInstId, vlCompInstId, vlCapConsumerOwnerId, vlCompInstId, capType, requirementName, capList, reqList);
 726                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(reqCapRelation, user, component.getUniqueId(), containerCompType);
 727                 ResourceRestUtils.checkSuccess(associateInstances);
 728         }
 729
 730         private void addDissociatedToExpected(RequirementCapabilityRelDef requirementDef) {
 731                 // adding to requirements
 732                 RequirementAndRelationshipPair relationship = requirementDef.getRelationships().get(0);
 733                 String type = relationship.getRelationship().getType();
 734                 String fromId = requirementDef.getFromNode();
 735                 Map<String, List<RequirementDefinition>> map = removedRequirements.get(fromId);
 736                 if (map != null) {
 737                         List<RequirementDefinition> list = map.get(type);
 738                         if (list != null && !list.isEmpty()) {
 739                                 List<RequirementDefinition> reqList = expectedContainerRequirements.get(type);
 740                                 if (reqList == null) {
 741                                         reqList = new ArrayList<>();
 742                                         expectedContainerRequirements.put(type, reqList);
 743                                 }
 744                                 reqList.add(list.remove(0));
 745                         }
 746                 }
 747
 748                 List<CapabilityDefinition> capList = expectedContainerCapabilities.get(type);
 749
 750                 for (CapabilityDefinition capabilityDefinition : capList) {
 751                         if (capabilityDefinition.getType().equals(type)) {
 752                                 int minOccurrences = Integer.parseInt(capabilityDefinition.getMinOccurrences()) + 1;
 753                                 String minOccurrencesString = Integer.toString(minOccurrences);
 754                                 capabilityDefinition.setMinOccurrences(minOccurrencesString);
 755                                 if (!capabilityDefinition.getMaxOccurrences().equals("UNBOUNDED")) {
 756                                         int maxOccurrences = Integer.parseInt(capabilityDefinition.getMaxOccurrences()) + 1;
 757                                         String maxOccurrencesString = Integer.toString(maxOccurrences);
 758                                         capabilityDefinition.setMaxOccurrences(maxOccurrencesString);
 759                                 }
 760                         }
 761                 }
 762                 expectedContainerCapabilities.put(type, capList);
 763         }
 764 }