test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/ReqCap.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.utils;
  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.HashMap;
  30 import java.util.HashSet;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Map.Entry;
  34 import java.util.function.Function;
  35 import java.util.Set;
  36 import java.util.stream.Collectors;
  37
  38 import org.apache.commons.lang3.tuple.ImmutablePair;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  41 import org.openecomp.sdc.be.model.CapabilityDefinition;
  42 import org.openecomp.sdc.be.model.Component;
  43 import org.openecomp.sdc.be.model.ComponentInstance;
  44 import org.openecomp.sdc.be.model.Product;
  45 import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
  46 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  47 import org.openecomp.sdc.be.model.RequirementDefinition;
  48 import org.openecomp.sdc.be.model.Resource;
  49 import org.openecomp.sdc.be.model.Service;
  50 import org.openecomp.sdc.be.model.User;
  51 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  52 import org.openecomp.sdc.ci.tests.datatypes.ComponentReqDetails;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  55 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  56 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  57 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  58 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
  59 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  60 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  61 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  62 import org.testng.Assert;
  63
  64 public class ReqCap {
  65
  66         public static Map<String, List<CapabilityDefinition>> expectedContainerCapabilities;
  67         public static Map<String, List<RequirementDefinition>> expectedContainerRequirements;
  68         public static Map<String, RequirementDefinition> removedRequirements;
  69         public static Map<String, ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>>> expectedContInstReqCap;
  70
  71         public static void verifyVFReqCap(String componentId) throws Exception {
  72                 RestResponse restResponse = ResourceRestUtils.getResource(componentId);
  73                 Resource resource = ResponseParser.parseToObject(restResponse.getResponse(), Resource.class);
  74                 verifyReqCap(resource);
  75         }
  76
  77         public static void verifyServiceReqCap(String componentId, User sdncDesignerDetails) throws Exception {
  78                 RestResponse restResponse = ServiceRestUtils.getService(componentId, sdncDesignerDetails);
  79                 Service service = ResponseParser.parseToObject(restResponse.getResponse(), Service.class);
  80                 verifyReqCap(service);
  81         }
  82
  83         public static void verifyProductReqCap(String componentId, User sdncPsDetails1) throws Exception {
  84                 RestResponse restResponse = ProductRestUtils.getProduct(componentId, sdncPsDetails1.getUserId());
  85                 Product product = ResponseParser.parseToObject(restResponse.getResponse(), Product.class);
  86                 verifyReqCap(product);
  87         }
  88
  89         public static void verifyReqCap(Component actualComponent) {
  90                 verifyContainerReqCap(actualComponent);
  91                 verifyCompInstReqCap(actualComponent);
  92         }
  93
  94         public RestResponse changeServiceInstanceVersion(String componentUniqueId, String serviceInstanceToReplaceUniqueId,
  95                         String serviceUniqueId, User sdncModifierDetails, ComponentTypeEnum componentType, boolean isHighestLevel)
  96                         throws Exception {
  97                 RestResponse changeResourceInstanceVersion = ProductRestUtils.changeServiceInstanceVersion(componentUniqueId,
  98                                 serviceInstanceToReplaceUniqueId, serviceUniqueId, sdncModifierDetails, componentType);
  99                 if (changeResourceInstanceVersion.getErrorCode().equals(BaseRestUtils.STATUS_CODE_SUCCESS) && isHighestLevel) {
 100                         /*
 101                          * // Add RI Capabilities and Requirements to expected MAP -->
 102                          * expectedVfCapabilities and expectedVfRequirements
 103                          *
 104                          * ComponentInstance componentInstance =
 105                          * ResponseParser.parseToObjectUsingMapper(
 106                          * changeResourceInstanceVersion.getResponse(),
 107                          * ComponentInstance.class);
 108                          * addCompInstReqCapToExpected(componentInstance, componentType);
 109                          */
 110                 }
 111                 return changeResourceInstanceVersion;
 112         }
 113
 114         public static void updateExpectedReqCapAfterChangeLifecycleState(String oldContainerUniqueIdToReplace,
 115                         String newContainerUniqueId) {
 116
 117                 // Update of container req/cap
 118
 119                 Set<String> compInstKeysToChange = new HashSet<>();
 120
 121                 for (String expKey : expectedContainerCapabilities.keySet()) {
 122                         List<CapabilityDefinition> expCapList = expectedContainerCapabilities.get(expKey);
 123                         for (CapabilityDefinition cap : expCapList) {
 124                                 String ownerId = cap.getOwnerId();
 125
 126                                 if (ownerId.contains(oldContainerUniqueIdToReplace)) {
 127                                         compInstKeysToChange.add(ownerId);
 128                                         cap.setOwnerId(cap.getOwnerId().replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
 129                                 }
 130                         }
 131                 }
 132
 133                 for (String expKey : expectedContainerRequirements.keySet()) {
 134                         List<RequirementDefinition> expCapList = expectedContainerRequirements.get(expKey);
 135                         for (RequirementDefinition cap : expCapList) {
 136                                 String ownerId = cap.getOwnerId();
 137                                 if (ownerId.contains(oldContainerUniqueIdToReplace)) {
 138                                         compInstKeysToChange.add(ownerId);
 139                                         cap.setOwnerId(cap.getOwnerId().replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
 140                                 }
 141                         }
 142                 }
 143
 144                 // Update of internal comp instances req/cap
 145                 for (String oldKey : compInstKeysToChange) {
 146                         ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> immutablePair = expectedContInstReqCap
 147                                         .get(oldKey);
 148                         if (immutablePair != null) {
 149                                 expectedContInstReqCap.remove(oldKey);
 150                                 String newKey = oldKey.replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId);
 151                                 expectedContInstReqCap.put(newKey, immutablePair);
 152                         }
 153                 }
 154         }
 155
 156         private static void verifyCompInstReqCap(Component actualComponent) {
 157                 List<ComponentInstance> componentInstances = actualComponent.getComponentInstances();
 158                 if (componentInstances != null) {
 159                         assertEquals(expectedContInstReqCap.size(), componentInstances.size());
 160                         for (ComponentInstance compInst : componentInstances) {
 161                                 String uniqueId = compInst.getUniqueId();
 162                                 // System.out.println("Verifying req/cap of component instance
 163                                 // "+ uniqueId);
 164                                 Map<String, List<RequirementDefinition>> actualCompInstReq = compInst.getRequirements();
 165                                 if (actualCompInstReq == null) {
 166                                         actualCompInstReq = new HashMap<>();
 167                                 }
 168                                 Map<String, List<CapabilityDefinition>> actualCompInstCap = compInst.getCapabilities();
 169                                 if (actualCompInstCap == null) {
 170                                         actualCompInstCap = new HashMap<>();
 171                                 }
 172                                 ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> expReqCap = expectedContInstReqCap
 173                                                 .get(uniqueId);
 174                                 assertNotNull(expReqCap);
 175                                 // System.out.println("expected instance requirements:
 176                                 // "+expReqCap.right);
 177                                 // System.out.println("expected instance capabilities:
 178                                 // "+expReqCap.left);
 179                                 // System.out.println("actual instance requirements:
 180                                 // "+actualCompInstReq);
 181                                 // System.out.println("actual instance capabilities:
 182                                 // "+actualCompInstCap);
 183
 184                                 // REQ comparison
 185                                 compareReqCapMaps(expReqCap.right, actualCompInstReq);
 186
 187                                 // CAP comparison
 188                                 compareReqCapMaps(expReqCap.left, actualCompInstCap);
 189                         }
 190
 191                 } else {
 192                         assertTrue(expectedContInstReqCap.isEmpty());
 193                 }
 194         }
 195
 196         private static void verifyContainerReqCap(Component actualComponent) {
 197                 Map<String, List<RequirementDefinition>> actualContainerRequirements = actualComponent.getRequirements();
 198                 if (actualContainerRequirements == null) {
 199                         actualContainerRequirements = new HashMap<>();
 200                 }
 201                 Map<String, List<CapabilityDefinition>> actualContainerCapabilities = actualComponent.getCapabilities();
 202                 if (actualContainerCapabilities == null) {
 203                         actualContainerCapabilities = new HashMap<>();
 204                 }
 205                 // System.out.println("Verifying req/cap of container component "+
 206                 // actualComponent.getUniqueId());
 207                 // System.out.println("expected container requirements:
 208                 // "+expectedContainerRequirements);
 209                 // System.out.println("expected container capabilities:
 210                 // "+expectedContainerCapabilities);
 211                 // System.out.println("actual container requirements:
 212                 // "+actualContainerRequirements);
 213                 // System.out.println("actual container capabilities:
 214                 // "+actualContainerCapabilities);
 215
 216                 // REQ comparison
 217                 compareReqCapMaps(expectedContainerRequirements, actualContainerRequirements);
 218
 219                 // CAP comparison
 220                 compareReqCapMaps(expectedContainerCapabilities, actualContainerCapabilities);
 221         }
 222
 223         private static <T> void compareReqCapMaps(Map<String, List<T>> expectedMap, Map<String, List<T>> actualMap) {
 224                 assertEquals(expectedMap.size(), actualMap.size());
 225                 for (String expKey : expectedMap.keySet()) {
 226                         List<?> expCapList = expectedMap.get(expKey);
 227                         List<?> actCapList = actualMap.get(expKey);
 228                         assertEquals(expCapList.size(), actCapList.size());
 229                         assertEquals(new HashSet<>(expCapList), new HashSet<>(actCapList));
 230                 }
 231         }
 232
 233         public static void addCompInstReqCapToExpected(ComponentInstance componentInstance,
 234                         ComponentTypeEnum containerComponentType, User sdncDesignerDetails) throws Exception {
 235
 236                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 237                 String uniqueId = componentInstance.getUniqueId();
 238                 String name = componentInstance.getName();
 239                 String originComponentId = componentInstance.getComponentUid();
 240                 RestResponse getResponse = null;
 241                 ComponentTypeEnum compInstType = getCompInstTypeByContainerType(containerComponentType);
 242                 Component component = null;
 243                 if (compInstType == ComponentTypeEnum.RESOURCE) {
 244                         getResponse = ResourceRestUtils.getResource(sdncDesignerDetails, originComponentId);
 245                         ResourceRestUtils.checkSuccess(getResponse);
 246                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Resource.class);
 247                 } else if (compInstType == ComponentTypeEnum.SERVICE) {
 248                         getResponse = ServiceRestUtils.getService(originComponentId, sdncDesignerDetails);
 249                         ResourceRestUtils.checkSuccess(getResponse);
 250                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Service.class);
 251                 } else {
 252                         Assert.fail("Unsupported type - " + containerComponentType);
 253                 }
 254
 255                 Map<String, List<RequirementDefinition>> resourceRequirements = component.getRequirements();
 256                 if (resourceRequirements == null) {
 257                         resourceRequirements = new HashMap<>();
 258                 }
 259
 260                 Function<Entry<String, List<RequirementDefinition>>, List<RequirementDefinition>> requirementDefinitionMapper = e -> new ArrayList<>(e.getValue().stream().map(item -> new RequirementDefinition(item)).collect(Collectors.toList()));
 261                 Map<String, List<RequirementDefinition>> reqCopy = resourceRequirements.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), requirementDefinitionMapper));
 262
 263                 Map<String, List<CapabilityDefinition>> resourceCapabilities = component.getCapabilities();
 264                 if (resourceCapabilities == null) {
 265                         resourceCapabilities = new HashMap<>();
 266                 }
 267
 268                 Function<Entry<String, List<CapabilityDefinition>>, List<CapabilityDefinition>> capabilityDefinitionMapper = e -> new ArrayList<>(e.getValue().stream().map(item -> new CapabilityDefinition(item)).collect(Collectors.toList()));
 269                 Map<String, List<CapabilityDefinition>> capCopy = resourceCapabilities.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), capabilityDefinitionMapper));
 270
 271                 setupContainerExpectedReqCap(uniqueId, name, resourceRequirements, resourceCapabilities);
 272                 if (component.getComponentType().equals(ComponentTypeEnum.RESOURCE)
 273                                 && ((Resource) component).getResourceType() != ResourceTypeEnum.VF) {
 274                         setupConstInstExpectedReqCap(uniqueId, name, reqCopy, capCopy);
 275                 }
 276
 277                 // adding entry for expected componentInstance
 278                 ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> compInstReqCapPair = new ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>>(
 279                                 capCopy, reqCopy);
 280                 expectedContInstReqCap.put(uniqueId, compInstReqCapPair);
 281         }
 282
 283         private static void setupContainerExpectedReqCap(String uniqueId, String name,
 284                         Map<String, List<RequirementDefinition>> componentRequirements,
 285                         Map<String, List<CapabilityDefinition>> componentCapabilities) {
 286                 for (Entry<String, List<RequirementDefinition>> resReq : componentRequirements.entrySet()) {
 287                         List<RequirementDefinition> reqListToAdd = resReq.getValue();
 288                         for (RequirementDefinition requirementDefinition : reqListToAdd) {
 289                                 requirementDefinition.setOwnerId(uniqueId);
 290                                 requirementDefinition.setOwnerName(name);
 291                         }
 292                         List<RequirementDefinition> expectedReqList = expectedContainerRequirements.get(resReq.getKey());
 293                         if (expectedReqList == null) {
 294                                 expectedReqList = reqListToAdd;
 295                         } else {
 296                                 expectedReqList.addAll(reqListToAdd);
 297                         }
 298                         expectedContainerRequirements.put(resReq.getKey(), expectedReqList);
 299                 }
 300
 301                 for (Entry<String, List<CapabilityDefinition>> resCap : componentCapabilities.entrySet()) {
 302                         List<CapabilityDefinition> capListToAdd = resCap.getValue();
 303                         for (CapabilityDefinition capDefinition : capListToAdd) {
 304                                 capDefinition.setOwnerId(uniqueId);
 305                                 capDefinition.setOwnerName(name);
 306                         }
 307                         List<CapabilityDefinition> expectedCapList = expectedContainerCapabilities.get(resCap.getKey());
 308                         if (expectedCapList == null) {
 309                                 expectedCapList = capListToAdd;
 310                         } else {
 311                                 expectedCapList.addAll(capListToAdd);
 312                         }
 313                         expectedContainerCapabilities.put(resCap.getKey(), expectedCapList);
 314                 }
 315         }
 316
 317         private static void setupConstInstExpectedReqCap(String uniqueId, String name,
 318                         Map<String, List<RequirementDefinition>> componentRequirements,
 319                         Map<String, List<CapabilityDefinition>> componentCapabilities) {
 320                 for (Entry<String, List<RequirementDefinition>> resReq : componentRequirements.entrySet()) {
 321                         List<RequirementDefinition> reqListToAdd = resReq.getValue();
 322                         for (RequirementDefinition requirementDefinition : reqListToAdd) {
 323                                 requirementDefinition.setOwnerId(uniqueId);
 324                                 requirementDefinition.setOwnerName(name);
 325                         }
 326                 }
 327
 328                 for (Entry<String, List<CapabilityDefinition>> resCap : componentCapabilities.entrySet()) {
 329                         List<CapabilityDefinition> capListToAdd = resCap.getValue();
 330                         for (CapabilityDefinition capDefinition : capListToAdd) {
 331                                 capDefinition.setOwnerId(uniqueId);
 332                                 capDefinition.setOwnerName(name);
 333                         }
 334                 }
 335         }
 336
 337         private static ComponentTypeEnum getCompInstTypeByContainerType(ComponentTypeEnum componentType) {
 338                 switch (componentType) {
 339                 case RESOURCE:
 340                         return ComponentTypeEnum.RESOURCE;
 341                 case SERVICE:
 342                         return ComponentTypeEnum.RESOURCE;
 343                 case PRODUCT:
 344                         return ComponentTypeEnum.SERVICE;
 345                 default:
 346                         break;
 347                 }
 348                 return null;
 349         }
 350
 351         public static void deleteCompInstReqCapFromExpected(String componentInstanceId) {
 352                 List<String> entriesRequirementsToRemove = new ArrayList<>();
 353                 List<String> entriesCapabilitiesToRemove = new ArrayList<>();
 354                 for (Entry<String, List<RequirementDefinition>> reqEntry : expectedContainerRequirements.entrySet()) {
 355                         List<RequirementDefinition> reqList = reqEntry.getValue();
 356                         List<RequirementDefinition> reqListToDelete = new ArrayList<>();
 357                         for (RequirementDefinition requirementDefinition : reqList) {
 358                                 if (requirementDefinition.getOwnerId().equals(componentInstanceId)) {
 359                                         reqListToDelete.add(requirementDefinition);
 360                                 }
 361                         }
 362                         reqList.removeAll(reqListToDelete);
 363                         if (reqList.isEmpty()) {
 364                                 entriesRequirementsToRemove.add(reqEntry.getKey());
 365                         }
 366                 }
 367
 368                 for (String ekey : entriesRequirementsToRemove) {
 369                         expectedContainerRequirements.remove(ekey);
 370                 }
 371
 372                 for (Entry<String, List<CapabilityDefinition>> capEntry : expectedContainerCapabilities.entrySet()) {
 373                         List<CapabilityDefinition> capList = capEntry.getValue();
 374                         List<CapabilityDefinition> capListToDelete = new ArrayList<>();
 375                         for (CapabilityDefinition capabilityDefinition : capList) {
 376                                 if (capabilityDefinition.getOwnerId().equals(componentInstanceId)) {
 377                                         capListToDelete.add(capabilityDefinition);
 378                                 }
 379                         }
 380                         capList.removeAll(capListToDelete);
 381                         if (capList.isEmpty()) {
 382                                 entriesCapabilitiesToRemove.add(capEntry.getKey());
 383                         }
 384                 }
 385                 for (String ekey : entriesCapabilitiesToRemove) {
 386                         expectedContainerCapabilities.remove(ekey);
 387                 }
 388
 389                 expectedContInstReqCap.remove(componentInstanceId);
 390
 391         }
 392
 393         // Automatically updates the expected req/cap of the container
 394         public static RestResponse createAtomicInstanceForVF(Resource containerDetails, Resource compInstOriginDetails,
 395                         User modifier) throws Exception {
 396                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.RESOURCE,
 397                                 true);
 398         }
 399
 400         // Automatically updates the expected req/cap of the container
 401         public static RestResponse createAtomicInstanceForService(Service containerDetails, Resource compInstOriginDetails,
 402                         User modifier) throws Exception {
 403                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
 404                                 true);
 405         }
 406
 407         // Automatically updates the expected req/cap of the container
 408         public static RestResponse createVFInstance(Service containerDetails, Resource compInstOriginDetails, User modifier)
 409                         throws Exception {
 410                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
 411                                 true);
 412         }
 413
 414         // Automatically updates the expected req/cap of the container
 415         public static RestResponse createServiceInstance(Product containerDetails, Service compInstOriginDetails,
 416                         User modifier) throws Exception {
 417                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.PRODUCT,
 418                                 true);
 419         }
 420
 421         // Automatically updates the expected req/cap of the container
 422         public static RestResponse deleteAtomicInstanceForVF(String compInstUniqueId, Resource containerDetails,
 423                         User modifier) throws IOException, Exception {
 424                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.RESOURCE, true);
 425         }
 426
 427         // Automatically updates the expected req/cap of the container
 428         public static RestResponse deleteAtomicInstanceForService(String compInstUniqueId, Service containerDetails,
 429                         User modifier) throws IOException, Exception {
 430                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, true);
 431         }
 432
 433         // Automatically updates the expected req/cap of the container
 434         public static RestResponse deleteVFInstance(String compInstUniqueId, Service containerDetails, User modifier)
 435                         throws IOException, Exception {
 436                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, true);
 437
 438         }
 439
 440         // Automatically updates the expected req/cap of the container
 441         public static RestResponse deleteServiceInstance(String compInstUniqueId, Product containerDetails, User modifier)
 442                         throws IOException, Exception {
 443                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.PRODUCT, true);
 444         }
 445
 446         // Setup of lower components - Doesn't affect req/cap of the container (for
 447         // example, setup of VF for testing a Product)
 448         public static RestResponse createAtomicInstanceForVFDuringSetup(Resource containerDetails,
 449                         Resource compInstOriginDetails, User modifier) throws Exception {
 450                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.RESOURCE,
 451                                 false);
 452         }
 453
 454         // Setup of lower components - Doesn't affect req/cap of the container (for
 455         // example, setup of VF for testing a Product)
 456         public static RestResponse createAtomicInstanceForServiceDuringSetup(Service containerDetails,
 457                         Resource compInstOriginDetails, User modifier) throws Exception {
 458                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
 459                                 false);
 460         }
 461
 462         // Setup of lower components - Doesn't affect req/cap of the container (for
 463         // example, setup of VF for testing a Product)
 464         public static RestResponse createVFInstanceDuringSetup(Service containerDetails, Resource compInstOriginDetails,
 465                         User modifier) throws Exception {
 466                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
 467                                 false);
 468         }
 469
 470         // Setup of lower components - Doesn't affect req/cap of the container (for
 471         // example, setup of VF for testing a Product)
 472         public static RestResponse createServiceInstanceDuringSetup(Product containerDetails, Service compInstOriginDetails,
 473                         User modifier) throws Exception {
 474                 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.PRODUCT,
 475                                 false);
 476         }
 477
 478         // Setup of lower components - Doesn't affect req/cap of the container (for
 479         // example, setup of VF for testing a Product)
 480         public static RestResponse deleteAtomicInstanceForVFDuringSetup(String compInstUniqueId, Resource containerDetails,
 481                         User modifier) throws IOException, Exception {
 482                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.RESOURCE, false);
 483         }
 484
 485         // Setup of lower components - Doesn't affect req/cap of the container (for
 486         // example, setup of VF for testing a Product)
 487         public static RestResponse deleteAtomicInstanceForServiceDuringSetup(String compInstUniqueId,
 488                         Service containerDetails, User modifier) throws IOException, Exception {
 489                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, false);
 490         }
 491
 492         // Setup of lower components - Doesn't affect req/cap of the container (for
 493         // example, setup of VF for testing a Product)
 494         public static RestResponse deleteVFInstanceDuringSetup(String compInstUniqueId, Service containerDetails,
 495                         User modifier) throws IOException, Exception {
 496                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.SERVICE, false);
 497
 498         }
 499
 500         // Setup of lower components - Doesn't affect req/cap of the container (for
 501         // example, setup of VF for testing a Product)
 502         public static RestResponse deleteServiceInstanceDuringSetup(String compInstUniqueId, Product containerDetails,
 503                         User modifier) throws IOException, Exception {
 504                 return deleteComponentInstance(compInstUniqueId, containerDetails, modifier, ComponentTypeEnum.PRODUCT, false);
 505         }
 506
 507         public static Component getComponentAndValidateRIs(Component componentDetails, int numberOfRIs,
 508                         int numberOfRelations, User sdncAdminDetails) throws IOException, Exception {
 509
 510                 RestResponse getResponse = null;
 511                 Component component = null;
 512                 if (componentDetails instanceof Resource) {
 513                         getResponse = ResourceRestUtils.getResource(sdncAdminDetails, componentDetails.getUniqueId());
 514                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Resource.class);
 515                 } else if (componentDetails instanceof Service) {
 516                         getResponse = ServiceRestUtils.getService((componentDetails.getUniqueId()), sdncAdminDetails);
 517                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Service.class);
 518                 } else if (componentDetails instanceof Product) {
 519                         getResponse = ProductRestUtils.getProduct(componentDetails.getUniqueId(), sdncAdminDetails.getUserId());
 520                         component = ResponseParser.parseToObjectUsingMapper(getResponse.getResponse(), Product.class);
 521                 } else {
 522                         Assert.fail("Unsupported type of componentDetails - " + componentDetails.getClass().getSimpleName());
 523                 }
 524                 ResourceRestUtils.checkSuccess(getResponse);
 525                 int numberOfActualRIs = component.getComponentInstances() != null ? component.getComponentInstances().size()
 526                                 : 0;
 527                 int numberOfActualRelations = component.getComponentInstancesRelations() != null
 528                                 ? component.getComponentInstancesRelations().size() : 0;
 529                 assertEquals("Check number of RIs meet the expected number", numberOfRIs, numberOfActualRIs);
 530                 assertEquals("Check number of RI relations meet the expected number", numberOfRelations,
 531                                 numberOfActualRelations);
 532                 verifyReqCap(component);
 533
 534                 return component;
 535         }
 536
 537         public static void getComponentAndValidateRIsAfterChangeLifecycleState(String oldComponentUniqueIdToReplace,
 538                         Component componentDetails, int numOfRIs, int numOfRelations, User sdncAdminDetails)
 539                         throws IOException, Exception {
 540                 updateExpectedReqCapAfterChangeLifecycleState(oldComponentUniqueIdToReplace, componentDetails.getUniqueId());
 541                 getComponentAndValidateRIs(componentDetails, numOfRIs, numOfRelations, sdncAdminDetails);
 542         }
 543
 544         private static RestResponse createComponentInstance(Component containerDetails, Component compInstOriginDetails,
 545                         User modifier, ComponentTypeEnum containerComponentTypeEnum, boolean isHighestLevel)
 546                         throws IOException, Exception {
 547                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory
 548                                 .getComponentInstance(compInstOriginDetails);
 549                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
 550                                 resourceInstanceReqDetails, modifier, containerDetails.getUniqueId(), containerComponentTypeEnum);
 551                 if (createResourceInstanceResponse.getErrorCode().equals(BaseRestUtils.STATUS_CODE_CREATED) && isHighestLevel) {
 552                         // Add RI Capabilities and Requirements to expected MAP -->
 553                         // expectedVfCapabilities and expectedVfRequirements
 554                         ComponentInstance componentInstance = ResponseParser
 555                                         .parseToObjectUsingMapper(createResourceInstanceResponse.getResponse(), ComponentInstance.class);
 556                         addCompInstReqCapToExpected(componentInstance, containerComponentTypeEnum, modifier);
 557                 }
 558                 return createResourceInstanceResponse;
 559         }
 560
 561         private static RestResponse deleteComponentInstance(String compInstUniqueId, Component containerDetails,
 562                         User modifier, ComponentTypeEnum componentTypeEnum, boolean isHighestLevel) throws Exception {
 563                 RestResponse deleteResourceInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(modifier,
 564                                 containerDetails.getUniqueId(), compInstUniqueId, componentTypeEnum);
 565                 if (deleteResourceInstanceResponse.getErrorCode().equals(BaseRestUtils.STATUS_CODE_DELETE) && isHighestLevel) {
 566                         deleteCompInstReqCapFromExpected(compInstUniqueId);
 567                 }
 568                 return deleteResourceInstanceResponse;
 569         }
 570
 571         public static RestResponse associateComponentInstancesForService(RequirementCapabilityRelDef requirementDef,
 572                         ComponentReqDetails containerDetails, User user) throws IOException {
 573
 574                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, user,
 575                                 containerDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
 576                 ResourceRestUtils.checkSuccess(associateInstances);
 577                 deleteAssociatedFromExpected(requirementDef);
 578                 return associateInstances;
 579         }
 580
 581         private static void deleteAssociatedFromExpected(RequirementCapabilityRelDef requirementDef) {
 582                 // removing from requirements
 583                 RequirementAndRelationshipPair relationship = requirementDef.getRelationships().get(0);
 584                 String type = relationship.getRelationship().getType();
 585                 String fromId = requirementDef.getFromNode();
 586                 List<RequirementDefinition> reqList = expectedContainerRequirements.get(type);
 587                 RequirementDefinition toDelete = null;
 588                 if (reqList != null) {
 589                         for (RequirementDefinition reqDef : reqList) {
 590                                 if (reqDef.getOwnerId().equals(fromId)) {
 591                                         toDelete = reqDef;
 592                                 }
 593                         }
 594                         if (toDelete != null) {
 595                                 reqList.remove(toDelete);
 596                                 if (reqList.isEmpty()) {
 597                                         expectedContainerRequirements.remove(type);
 598                                 }
 599                                 removedRequirements.put(toDelete.getCapability() + " " + toDelete.getOwnerId(), toDelete);
 600                         }
 601                 }
 602         }
 603
 604         public static void dissociateComponentInstancesForService(RequirementCapabilityRelDef requirementDef,
 605                         ComponentReqDetails containerDetails, User user) throws IOException {
 606
 607                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, user,
 608                                 containerDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
 609                 ResourceRestUtils.checkSuccess(dissociateInstances);
 610                 addDissociatedToExpected(requirementDef);
 611         }
 612
 613         private static void addDissociatedToExpected(RequirementCapabilityRelDef requirementDef) {
 614                 // adding to requirements
 615                 RequirementAndRelationshipPair relationship = requirementDef.getRelationships().get(0);
 616                 String type = relationship.getRelationship().getType();
 617                 String fromId = requirementDef.getFromNode();
 618                 String key = type + " " + fromId;
 619                 RequirementDefinition requirementDefinition = removedRequirements.get(key);
 620                 if (requirementDefinition != null) {
 621                         List<RequirementDefinition> reqList = expectedContainerRequirements.get(type);
 622                         if (reqList == null) {
 623                                 reqList = new ArrayList<>();
 624                                 expectedContainerRequirements.put(type, reqList);
 625                         }
 626                         reqList.add(requirementDefinition);
 627                 }
 628         }
 629
 630 }