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