2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.utils;
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertNotNull;
25 import static org.testng.AssertJUnit.assertTrue;
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;
33 import java.util.Map.Entry;
35 import java.util.function.Function;
36 import java.util.stream.Collectors;
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.RelationshipInfo;
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;
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;
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);
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);
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);
89 public static void verifyReqCap(Component actualComponent) {
90 verifyContainerReqCap(actualComponent);
91 verifyCompInstReqCap(actualComponent);
94 public RestResponse changeServiceInstanceVersion(String componentUniqueId, String serviceInstanceToReplaceUniqueId,
95 String serviceUniqueId, User sdncModifierDetails, ComponentTypeEnum componentType, boolean isHighestLevel)
97 RestResponse changeResourceInstanceVersion = ProductRestUtils.changeServiceInstanceVersion(componentUniqueId,
98 serviceInstanceToReplaceUniqueId, serviceUniqueId, sdncModifierDetails, componentType);
99 if (changeResourceInstanceVersion.getErrorCode().equals(BaseRestUtils.STATUS_CODE_SUCCESS) && isHighestLevel) {
101 * // Add RI Capabilities and Requirements to expected MAP -->
102 * expectedVfCapabilities and expectedVfRequirements
104 * ComponentInstance componentInstance =
105 * ResponseParser.parseToObjectUsingMapper(
106 * changeResourceInstanceVersion.getResponse(),
107 * ComponentInstance.class);
108 * addCompInstReqCapToExpected(componentInstance, componentType);
111 return changeResourceInstanceVersion;
114 public static void updateExpectedReqCapAfterChangeLifecycleState(String oldContainerUniqueIdToReplace,
115 String newContainerUniqueId) {
117 // Update of container req/cap
119 Set<String> compInstKeysToChange = new HashSet<>();
121 for (String expKey : expectedContainerCapabilities.keySet()) {
122 List<CapabilityDefinition> expCapList = expectedContainerCapabilities.get(expKey);
123 for (CapabilityDefinition cap : expCapList) {
124 String ownerId = cap.getOwnerId();
126 if (ownerId.contains(oldContainerUniqueIdToReplace)) {
127 compInstKeysToChange.add(ownerId);
128 cap.setOwnerId(cap.getOwnerId().replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
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));
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
148 if (immutablePair != null) {
149 expectedContInstReqCap.remove(oldKey);
150 String newKey = oldKey.replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId);
151 expectedContInstReqCap.put(newKey, immutablePair);
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
164 Map<String, List<RequirementDefinition>> actualCompInstReq = compInst.getRequirements();
165 if (actualCompInstReq == null) {
166 actualCompInstReq = new HashMap<>();
168 Map<String, List<CapabilityDefinition>> actualCompInstCap = compInst.getCapabilities();
169 if (actualCompInstCap == null) {
170 actualCompInstCap = new HashMap<>();
172 ImmutablePair<Map<String, List<CapabilityDefinition>>, Map<String, List<RequirementDefinition>>> expReqCap = expectedContInstReqCap
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);
185 compareReqCapMaps(expReqCap.right, actualCompInstReq);
188 compareReqCapMaps(expReqCap.left, actualCompInstCap);
192 assertTrue(expectedContInstReqCap.isEmpty());
196 private static void verifyContainerReqCap(Component actualComponent) {
197 Map<String, List<RequirementDefinition>> actualContainerRequirements = actualComponent.getRequirements();
198 if (actualContainerRequirements == null) {
199 actualContainerRequirements = new HashMap<>();
201 Map<String, List<CapabilityDefinition>> actualContainerCapabilities = actualComponent.getCapabilities();
202 if (actualContainerCapabilities == null) {
203 actualContainerCapabilities = new HashMap<>();
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);
217 compareReqCapMaps(expectedContainerRequirements, actualContainerRequirements);
220 compareReqCapMaps(expectedContainerCapabilities, actualContainerCapabilities);
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));
233 public static void addCompInstReqCapToExpected(ComponentInstance componentInstance,
234 ComponentTypeEnum containerComponentType, User sdncDesignerDetails) throws Exception {
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);
252 Assert.fail("Unsupported type - " + containerComponentType);
255 Map<String, List<RequirementDefinition>> resourceRequirements = component.getRequirements();
256 if (resourceRequirements == null) {
257 resourceRequirements = new HashMap<>();
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));
263 Map<String, List<CapabilityDefinition>> resourceCapabilities = component.getCapabilities();
264 if (resourceCapabilities == null) {
265 resourceCapabilities = new HashMap<>();
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));
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);
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>>>(
280 expectedContInstReqCap.put(uniqueId, compInstReqCapPair);
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);
292 List<RequirementDefinition> expectedReqList = expectedContainerRequirements.get(resReq.getKey());
293 if (expectedReqList == null) {
294 expectedReqList = reqListToAdd;
296 expectedReqList.addAll(reqListToAdd);
298 expectedContainerRequirements.put(resReq.getKey(), expectedReqList);
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);
307 List<CapabilityDefinition> expectedCapList = expectedContainerCapabilities.get(resCap.getKey());
308 if (expectedCapList == null) {
309 expectedCapList = capListToAdd;
311 expectedCapList.addAll(capListToAdd);
313 expectedContainerCapabilities.put(resCap.getKey(), expectedCapList);
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);
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);
337 private static ComponentTypeEnum getCompInstTypeByContainerType(ComponentTypeEnum componentType) {
338 switch (componentType) {
340 return ComponentTypeEnum.RESOURCE;
342 return ComponentTypeEnum.RESOURCE;
344 return ComponentTypeEnum.SERVICE;
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);
362 reqList.removeAll(reqListToDelete);
363 if (reqList.isEmpty()) {
364 entriesRequirementsToRemove.add(reqEntry.getKey());
368 for (String ekey : entriesRequirementsToRemove) {
369 expectedContainerRequirements.remove(ekey);
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);
380 capList.removeAll(capListToDelete);
381 if (capList.isEmpty()) {
382 entriesCapabilitiesToRemove.add(capEntry.getKey());
385 for (String ekey : entriesCapabilitiesToRemove) {
386 expectedContainerCapabilities.remove(ekey);
389 expectedContInstReqCap.remove(componentInstanceId);
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,
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,
407 // Automatically updates the expected req/cap of the container
408 public static RestResponse createVFInstance(Service containerDetails, Resource compInstOriginDetails, User modifier)
410 return createComponentInstance(containerDetails, compInstOriginDetails, modifier, ComponentTypeEnum.SERVICE,
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,
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);
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);
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);
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);
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,
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,
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,
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,
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);
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);
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);
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);
507 public static Component getComponentAndValidateRIs(Component componentDetails, int numberOfRIs,
508 int numberOfRelations, User sdncAdminDetails) throws IOException, Exception {
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);
522 Assert.fail("Unsupported type of componentDetails - " + componentDetails.getClass().getSimpleName());
524 ResourceRestUtils.checkSuccess(getResponse);
525 int numberOfActualRIs = component.getComponentInstances() != null ? component.getComponentInstances().size()
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);
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);
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);
558 return createResourceInstanceResponse;
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);
568 return deleteResourceInstanceResponse;
571 public static RestResponse associateComponentInstancesForService(RequirementCapabilityRelDef requirementDef,
572 ComponentReqDetails containerDetails, User user) throws IOException {
574 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, user,
575 containerDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
576 ResourceRestUtils.checkSuccess(associateInstances);
577 deleteAssociatedFromExpected(requirementDef);
578 return associateInstances;
581 private static void deleteAssociatedFromExpected(RequirementCapabilityRelDef requirementDef) {
582 // removing from requirements
583 RelationshipInfo relationship = requirementDef.getRelationships().get(0).getRelation();
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)) {
594 if (toDelete != null) {
595 reqList.remove(toDelete);
596 if (reqList.isEmpty()) {
597 expectedContainerRequirements.remove(type);
599 removedRequirements.put(toDelete.getCapability() + " " + toDelete.getOwnerId(), toDelete);
604 public static void dissociateComponentInstancesForService(RequirementCapabilityRelDef requirementDef,
605 ComponentReqDetails containerDetails, User user) throws IOException {
607 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, user,
608 containerDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
609 ResourceRestUtils.checkSuccess(dissociateInstances);
610 addDissociatedToExpected(requirementDef);
613 private static void addDissociatedToExpected(RequirementCapabilityRelDef requirementDef) {
614 // adding to requirements
615 RelationshipInfo relationship = requirementDef.getRelationships().get(0).getRelation();
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);
626 reqList.add(requirementDefinition);