catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceRelationMergeTest.java

   1 package org.openecomp.sdc.be.components.merge.instance;
   2
   3 import fj.data.Either;
   4 import org.junit.Before;
   5 import org.junit.Test;
   6 import org.junit.runner.RunWith;
   7 import org.mockito.ArgumentCaptor;
   8 import org.mockito.Captor;
   9 import org.mockito.Mock;
  10 import org.mockito.Mockito;
  11 import org.mockito.junit.MockitoJUnitRunner;
  12 import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils;
  13 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  14 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  15 import org.openecomp.sdc.be.model.CapabilityDefinition;
  16 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  17 import org.openecomp.sdc.be.model.Component;
  18 import org.openecomp.sdc.be.model.ComponentInstance;
  19 import org.openecomp.sdc.be.model.RelationshipImpl;
  20 import org.openecomp.sdc.be.model.RelationshipInfo;
  21 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  22 import org.openecomp.sdc.be.model.RequirementDefinition;
  23 import org.openecomp.sdc.be.model.Resource;
  24 import org.openecomp.sdc.be.model.Service;
  25 import org.openecomp.sdc.be.model.User;
  26 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  27 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  28
  29 import java.util.ArrayList;
  30 import java.util.HashMap;
  31 import java.util.LinkedList;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.stream.IntStream;
  35
  36 import static org.junit.Assert.assertEquals;
  37 import static org.junit.Assert.assertNotNull;
  38 import static org.junit.Assert.assertNull;
  39 import static org.mockito.Mockito.verify;
  40 import static org.mockito.Mockito.when;
  41
  42 @RunWith(MockitoJUnitRunner.class)
  43 public class ComponentInstanceRelationMergeTest {
  44     private ComponentInstanceRelationMerge compInstanceRelationMerge;
  45     @Mock
  46     private DataForMergeHolder dataHolder;
  47     private Component containerComponent;
  48     private Component updatedContainerComponent;
  49     private ComponentInstance currentResourceInstance;
  50
  51     private RequirementCapabilityRelDef requirementDef1;
  52     private RequirementCapabilityRelDef requirementDef2;
  53     private RequirementCapabilityRelDef capabilityDef1;
  54     private RequirementCapabilityRelDef capabilityDef2;
  55
  56     @Mock
  57     private ToscaOperationFacade toscaOperationFacade;
  58
  59     @Mock
  60     private User user;
  61
  62     @Captor
  63     ArgumentCaptor<VfRelationsMergeInfo> argumentCaptor;
  64
  65
  66     @Before
  67     public void startUp() {
  68         compInstanceRelationMerge = new ComponentInstanceRelationMerge();
  69         compInstanceRelationMerge.setToscaOperationFacade(toscaOperationFacade);
  70
  71         MergeInstanceUtils mergeInstanceUtils = new MergeInstanceUtils();
  72         mergeInstanceUtils.setToscaOperationFacade(toscaOperationFacade);
  73         compInstanceRelationMerge.setMergeInstanceUtils(mergeInstanceUtils);
  74
  75         containerComponent = new Service();
  76         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
  77
  78         requirementDef1 = createRequirementDef("SRV1.VF1.VFI_1", "SRV1.VF2.VFI_1", "SRV1.VF1.VFC_1.VFCI_1", "Requirement1");
  79         resourceInstancesRelations.add(requirementDef1);
  80         requirementDef2 = createRequirementDef("SRV1.VF1.VFI_1", "SRV1.VF3.VFI_1", "SRV1.VF1.VFC_2.VFCI_2", "Requirement2");
  81         resourceInstancesRelations.add(requirementDef2);
  82
  83
  84         capabilityDef1 = createCapabilityDef("SRV1.VF4.VFI_1", "SRV1.VF1.VFI_1", "SRV1.VF1.VFC_3.VFCI_3", "Capability3");
  85         resourceInstancesRelations.add(capabilityDef1);
  86         capabilityDef2 = createCapabilityDef("SRV1.VF5.VFI_1", "SRV1.VF1.VFI_1", "SRV1.VF1.VFC_4.VFCI_1", "Capability4");
  87         resourceInstancesRelations.add(capabilityDef2);
  88
  89         containerComponent.setComponentInstancesRelations(resourceInstancesRelations );
  90
  91         currentResourceInstance = new ComponentInstance();
  92         currentResourceInstance.setUniqueId("SRV1.VF1.VFI_1");
  93         currentResourceInstance.setComponentUid("SRV1.VF1");
  94         currentResourceInstance.setIsProxy(false);
  95
  96         updatedContainerComponent = new Service();
  97         updatedContainerComponent.setUniqueId("123123123123123123");
  98     }
  99
 100     @Test
 101     public void testSaveDataBeforeMerge() {
 102         Resource vf = new Resource();
 103
 104         List<ComponentInstance> vfcInstances = new ArrayList<>();
 105         vfcInstances.add(createVfci("vfc_A", "SRV1.VF1.VFC_1.VFCI_1", "SRV1.VF1.VFC_1", true));
 106         vfcInstances.add(createVfci("vfc_B", "SRV1.VF1.VFC_2.VFCI_2", "SRV1.VF1.VFC_2", true));
 107         vfcInstances.add(createVfci("vfc_C", "SRV1.VF1.VFC_3.VFCI_3", "SRV1.VF1.VFC_3", false));
 108         vfcInstances.add(createVfci("vfc_D", "SRV1.VF1.VFC_4.VFCI_1", "SRV1.VF1.VFC_4", true));
 109         vf.setComponentInstances(vfcInstances);
 110         vf.setComponentType(ComponentTypeEnum.RESOURCE);
 111         vf.setResourceType(ResourceTypeEnum.VF);
 112
 113         compInstanceRelationMerge.saveDataBeforeMerge(dataHolder, containerComponent, currentResourceInstance, vf);
 114
 115         verify(dataHolder).setVfRelationsInfo(argumentCaptor.capture());
 116         VfRelationsMergeInfo relationsMergeInfo = argumentCaptor.getValue();
 117         List<RelationMergeInfo> fromRelationsMergeInfo = relationsMergeInfo.getFromRelationsInfo();
 118         List<RelationMergeInfo> toRelationsMergeInfo = relationsMergeInfo.getToRelationsInfo();
 119
 120         assertNotNull("Expected not null list of relations merge info", fromRelationsMergeInfo);
 121         assertNotNull("Expected not null list of relations merge info", toRelationsMergeInfo);
 122
 123         assertEquals("Expected 2 elements", 2, fromRelationsMergeInfo.size());
 124         assertEquals("Expected 1 elements", 1, toRelationsMergeInfo.size());
 125     }
 126
 127     @Test
 128     public void testMergeDataAfterCreate_NoSavedData() {
 129         compInstanceRelationMerge.mergeDataAfterCreate(user, dataHolder, updatedContainerComponent, "SRV1.VF1.VFI_2");
 130
 131         verify(dataHolder).getVfRelationsMergeInfo();
 132         List<RequirementCapabilityRelDef> relations = updatedContainerComponent.getComponentInstancesRelations();
 133         assertNull("Expected no relations", relations);
 134     }
 135
 136     @Test
 137     public void testMergeDataAfterCreate() {
 138         Resource vf = new Resource();
 139
 140         List<ComponentInstance> vfcInstances = new ArrayList<>();
 141         vfcInstances.add(createVfci("vfc_A", "SRV1.VF1.VFC_1.VFCI_1", "SRV1.VF1.VFC_1", true));
 142         vfcInstances.add(createVfci("vfc_B", "SRV1.VF1.VFC_2.VFCI_2", "SRV1.VF1.VFC_2", true));
 143         vfcInstances.add(createVfci("vfc_C", "SRV1.VF1.VFC_3.VFCI_3", "SRV1.VF1.VFC_3", false));
 144         vfcInstances.add(createVfci("vfc_D", "SRV1.VF1.VFC_4.VFCI_1", "SRV1.VF1.VFC_4", true));
 145         vf.setComponentInstances(vfcInstances);
 146         vf.setComponentType(ComponentTypeEnum.RESOURCE);
 147         vf.setResourceType(ResourceTypeEnum.VF);
 148
 149         Either<Component, StorageOperationStatus> eitherVF = Either.left(vf);
 150         when(toscaOperationFacade.getToscaElement("SRV1.VF1")).thenReturn(eitherVF);
 151
 152
 153         List<RelationMergeInfo> fromRelationsMergeInfo = new ArrayList<>();
 154         List<RelationMergeInfo> toRelationsMergeInfo = new ArrayList<>();
 155
 156         RelationMergeInfo relationMergeInfo1 = new RelationMergeInfo("CapabilityType1", "capabilityA", "vfc_A", requirementDef1);
 157         fromRelationsMergeInfo.add(relationMergeInfo1);
 158         RelationMergeInfo relationMergeInfo2 = new RelationMergeInfo("CapabilityType4", "capabilityD", "vfc_D", capabilityDef2);
 159         toRelationsMergeInfo.add(relationMergeInfo2);
 160
 161         VfRelationsMergeInfo relationsMergeInfo = new VfRelationsMergeInfo(fromRelationsMergeInfo, toRelationsMergeInfo);
 162
 163         when(dataHolder.getVfRelationsMergeInfo()).thenReturn(relationsMergeInfo);
 164
 165         List<ComponentInstance> componentInstances = new ArrayList<>();
 166         componentInstances.add(createVfi("SRV1.VF1", "SRV1.VF1.VFI_2"));
 167         componentInstances.add(createVfi("SRV1.VF2", "SRV1.VF2.VFI_1"));
 168         componentInstances.add(createVfi("SRV1.VF3", "SRV1.VF3.VFI_1"));
 169         componentInstances.add(createVfi("SRV1.VF4", "SRV1.VF4.VFI_1"));
 170         componentInstances.add(createVfi("SRV1.VF5", "SRV1.VF5.VFI_1"));
 171         updatedContainerComponent.setComponentInstances(componentInstances);
 172
 173         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 174         updatedContainerComponent.setComponentInstancesRelations(resourceInstancesRelations);
 175
 176         when(toscaOperationFacade.associateResourceInstances(Mockito.anyString(), Mockito.anyList())).thenReturn(StorageOperationStatus.OK);
 177
 178         compInstanceRelationMerge.mergeDataAfterCreate(user, dataHolder, updatedContainerComponent, "SRV1.VF1.VFI_2");
 179
 180         verify(dataHolder).getVfRelationsMergeInfo();
 181         verify(toscaOperationFacade).associateResourceInstances(Mockito.anyString(), Mockito.anyList());
 182
 183         List<RequirementCapabilityRelDef> relations = updatedContainerComponent.getComponentInstancesRelations();
 184         assertEquals("Expected 2 relations", 2, relations.size());
 185
 186
 187         RequirementCapabilityRelDef capabilityRelDef = relations.get(0);
 188         assertEquals("SRV1.VF1.VFC_4.VFCI_1", capabilityRelDef.resolveSingleRelationship().getRelation().getCapabilityOwnerId());
 189         assertEquals("SRV1.VF5.VFI_1", capabilityRelDef.getFromNode());
 190         assertEquals("SRV1.VF1.VFI_2", capabilityRelDef.getToNode());
 191
 192         RequirementCapabilityRelDef requirementRelDef = relations.get(1);
 193         assertEquals("SRV1.VF1.VFC_1.VFCI_1", requirementRelDef.resolveSingleRelationship().getRelation().getRequirementOwnerId());
 194         assertEquals("SRV1.VF1.VFI_2", requirementRelDef.getFromNode());
 195         assertEquals("SRV1.VF2.VFI_1", requirementRelDef.getToNode());
 196     }
 197
 198
 199
 200     @Test
 201     public void testMergeDataAfterCreate_OwnerChanged() {
 202         Resource vf = new Resource();
 203
 204         List<ComponentInstance> vfcInstances = new ArrayList<>();
 205         vfcInstances.add(createVfci("vfc_A", "SRV1.VF1.VFC_1.VFCI_2", "SRV1.VF1.VFC_1", true));
 206         vfcInstances.add(createVfci("vfc_B", "SRV1.VF1.VFC_2.VFCI_2", "SRV1.VF1.VFC_2", true));
 207         vfcInstances.add(createVfci("vfc_C", "SRV1.VF1.VFC_3.VFCI_3", "SRV1.VF1.VFC_3", false));
 208         vfcInstances.add(createVfci("vfc_D", "SRV1.VF1.VFC_4.VFCI_2", "SRV1.VF1.VFC_4", true));
 209         vf.setComponentInstances(vfcInstances);
 210         vf.setComponentType(ComponentTypeEnum.RESOURCE);
 211         vf.setResourceType(ResourceTypeEnum.VF);
 212
 213         Either<Component, StorageOperationStatus> eitherVF = Either.left(vf);
 214         when(toscaOperationFacade.getToscaElement("SRV1.VF1")).thenReturn(eitherVF);
 215
 216
 217         List<RelationMergeInfo> fromRelationsMergeInfo = new ArrayList<>();
 218         List<RelationMergeInfo> toRelationsMergeInfo = new ArrayList<>();
 219
 220         RelationMergeInfo relationMergeInfo1 = new RelationMergeInfo("CapabilityType1", "capabilityA", "vfc_A", requirementDef1);
 221         fromRelationsMergeInfo.add(relationMergeInfo1);
 222         RelationMergeInfo relationMergeInfo2 = new RelationMergeInfo("CapabilityType4", "capabilityD", "vfc_D", capabilityDef2);
 223         toRelationsMergeInfo.add(relationMergeInfo2);
 224
 225         VfRelationsMergeInfo relationsMergeInfo = new VfRelationsMergeInfo(fromRelationsMergeInfo, toRelationsMergeInfo);
 226
 227         when(dataHolder.getVfRelationsMergeInfo()).thenReturn(relationsMergeInfo);
 228
 229         List<ComponentInstance> componentInstances = new ArrayList<>();
 230         componentInstances.add(createVfi("SRV1.VF1", "SRV1.VF1.VFI_2"));
 231         componentInstances.add(createVfi("SRV1.VF2", "SRV1.VF2.VFI_1"));
 232         componentInstances.add(createVfi("SRV1.VF3", "SRV1.VF3.VFI_1"));
 233         componentInstances.add(createVfi("SRV1.VF4", "SRV1.VF4.VFI_1"));
 234         componentInstances.add(createVfi("SRV1.VF5", "SRV1.VF5.VFI_1"));
 235         updatedContainerComponent.setComponentInstances(componentInstances);
 236
 237         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 238         updatedContainerComponent.setComponentInstancesRelations(resourceInstancesRelations);
 239
 240         when(toscaOperationFacade.associateResourceInstances(Mockito.anyString(), Mockito.anyList())).thenReturn(StorageOperationStatus.OK);
 241
 242         compInstanceRelationMerge.mergeDataAfterCreate(user, dataHolder, updatedContainerComponent, "SRV1.VF1.VFI_2");
 243
 244         verify(dataHolder).getVfRelationsMergeInfo();
 245         verify(toscaOperationFacade).associateResourceInstances(Mockito.anyString(), Mockito.anyList());
 246
 247         List<RequirementCapabilityRelDef> relations = updatedContainerComponent.getComponentInstancesRelations();
 248         assertEquals("Expected 2 relations", 2, relations.size());
 249
 250
 251         RequirementCapabilityRelDef capabilityRelDef = relations.get(0);
 252         assertEquals("SRV1.VF1.VFC_4.VFCI_2", capabilityRelDef.resolveSingleRelationship().getRelation().getCapabilityOwnerId());
 253         assertEquals("SRV1.VF5.VFI_1", capabilityRelDef.getFromNode());
 254         assertEquals("SRV1.VF1.VFI_2", capabilityRelDef.getToNode());
 255
 256         RequirementCapabilityRelDef requirementRelDef = relations.get(1);
 257         assertEquals("SRV1.VF1.VFC_1.VFCI_2", requirementRelDef.resolveSingleRelationship().getRelation().getRequirementOwnerId());
 258         assertEquals("SRV1.VF1.VFI_2", requirementRelDef.getFromNode());
 259         assertEquals("SRV1.VF2.VFI_1", requirementRelDef.getToNode());
 260     }
 261
 262
 263     /**
 264      * @param vfId
 265      * @param vfiUniqueId
 266      * @return
 267      */
 268     private ComponentInstance createVfi(String vfId, String vfiUniqueId) {
 269         ComponentInstance vfi = new ComponentInstance();
 270         vfi.setUniqueId(vfiUniqueId);
 271         vfi.setComponentUid(vfId);
 272
 273         Resource vf = new Resource();
 274         vf.setUniqueId(vfId);
 275         return vfi;
 276     }
 277
 278     private ComponentInstance createVfci(String name, String uniqueId, String componentUid, boolean foundVfc) {
 279         ComponentInstance compInst = new ComponentInstance();
 280         compInst.setName(name);
 281         compInst.setUniqueId(uniqueId);
 282         compInst.setComponentUid(componentUid);
 283
 284         if(foundVfc) {
 285             createVfc(componentUid);
 286         }
 287         else {
 288             failLoadVfc(componentUid);
 289         }
 290         return compInst;
 291     }
 292
 293     private void failLoadVfc(String uid) {
 294         Either<Component, StorageOperationStatus> eitherVFC = Either.right(StorageOperationStatus.NOT_FOUND);
 295         when(toscaOperationFacade.getToscaElement(uid)).thenReturn(eitherVFC);
 296     }
 297
 298     private Component createVfc(String uid) {
 299         Resource vfc = new Resource();
 300         vfc.setUniqueId(uid);
 301
 302         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 303         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();;
 304         IntStream.range(0, 5).forEach(i -> {
 305
 306             List<CapabilityDefinition> capList = new LinkedList<>();
 307             capList.add(null);
 308             CapabilityDefinition capDef = new CapabilityDefinition();
 309             capDef.setName("CapabilityName" + i);
 310             capDef.setUniqueId("Capability" + i);
 311             capDef.setType("CapabilityType" + i);
 312             capList.add(capDef);
 313             capabilities.put("Key" + i, capList);
 314
 315             List<RequirementDefinition> reqList = new LinkedList<>();
 316             reqList.add(null);
 317             RequirementDefinition reqDef = new RequirementDefinition();
 318             reqDef.setName("RequirementName" + i);
 319             reqDef.setUniqueId("Requirement" + i);
 320             reqDef.setCapability("CapabilityType" + i);
 321             reqList.add(reqDef);
 322             requirements.put("Key" + i, reqList);
 323
 324         });
 325         vfc.setCapabilities(capabilities );
 326         vfc.setRequirements(requirements);
 327
 328         Either<Component, StorageOperationStatus> eitherVFC = Either.left(vfc);
 329         when(toscaOperationFacade.getToscaElement(uid)).thenReturn(eitherVFC);
 330
 331         return vfc;
 332     }
 333
 334     private RequirementCapabilityRelDef createRequirementCapabilityDef(String fromNode, String toNode) {
 335         RequirementCapabilityRelDef reqCapDef = new RequirementCapabilityRelDef();
 336
 337         reqCapDef.setFromNode(fromNode);
 338         reqCapDef.setToNode(toNode);
 339
 340         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 341         CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
 342         relationships.add(capabilityRequirementRelationship);
 343         reqCapDef.setRelationships(relationships);
 344
 345         return reqCapDef;
 346     }
 347
 348     private RequirementCapabilityRelDef createRequirementDef(String fromNode, String toNode, String ownerId, String requirementUid) {
 349         RequirementCapabilityRelDef reqCapDef = createRequirementCapabilityDef(fromNode, toNode);
 350         CapabilityRequirementRelationship capabilityRequirementRelationship = reqCapDef.resolveSingleRelationship();
 351
 352         RelationshipInfo relationshipInfo = new RelationshipInfo();
 353         relationshipInfo.setRequirementOwnerId(ownerId);
 354         relationshipInfo.setRequirementUid(requirementUid);
 355         relationshipInfo.setRelationships(new RelationshipImpl());
 356         capabilityRequirementRelationship.setRelation(relationshipInfo );
 357
 358
 359
 360         return reqCapDef;
 361     }
 362
 363     private RequirementCapabilityRelDef createCapabilityDef(String fromNode, String toNode, String ownerId, String capabilityUid) {
 364         RequirementCapabilityRelDef reqCapDef = createRequirementCapabilityDef(fromNode, toNode);
 365         CapabilityRequirementRelationship capabilityRequirementRelationship = reqCapDef.resolveSingleRelationship();
 366
 367         RelationshipInfo relationshipInfo = new RelationshipInfo();
 368         relationshipInfo.setCapabilityOwnerId(ownerId);
 369         relationshipInfo.setCapabilityUid(capabilityUid);
 370         relationshipInfo.setRelationships(new RelationshipImpl());
 371         capabilityRequirementRelationship.setRelation(relationshipInfo );
 372
 373         return reqCapDef;
 374     }
 375
 376
 377
 378 }