gerrit.onap Code Review - sdc.git/blob

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