catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/capability/SimpleCapabilityResolverTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 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.be.components.merge.capability;
  22
  23 import com.google.common.collect.ImmutableMap;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.mockito.InjectMocks;
  28 import org.mockito.Mock;
  29 import org.mockito.junit.MockitoJUnitRunner;
  30 import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils;
  31 import org.openecomp.sdc.be.components.utils.CapabilityDefinitionBuilder;
  32 import org.openecomp.sdc.be.components.utils.ComponentInstanceBuilder;
  33 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  34 import org.openecomp.sdc.be.model.CapabilityDefinition;
  35 import org.openecomp.sdc.be.model.ComponentInstance;
  36 import org.openecomp.sdc.be.model.Resource;
  37
  38 import java.util.Map;
  39
  40 import static java.util.Arrays.asList;
  41 import static java.util.Collections.emptyMap;
  42 import static org.assertj.core.api.Assertions.assertThat;
  43 import static org.mockito.Mockito.when;
  44
  45 @RunWith(MockitoJUnitRunner.class)
  46 public class SimpleCapabilityResolverTest {
  47
  48     public static final String NEW_OWNER_ID1 = "owner1";
  49     public static final String NEW_OWNER_ID2 = "owner2";
  50     public static final String OLD_OWNER_ID1 = "oldOwner1";
  51     private static final String OLD_OWNER_ID2 = "oldOwner2";
  52     public static final String OLD_OWNER_ID3 = "oldOwner3";
  53     @InjectMocks
  54     private SimpleCapabilityResolver testInstance;
  55     @Mock
  56     private MergeInstanceUtils MergeInstanceUtils;
  57
  58     private CapabilityDefinition capName1Owner1Type1;
  59     private CapabilityDefinition capName1Owner1Type2;
  60     private CapabilityDefinition capName1Owner2Type1;
  61     private CapabilityDefinition capName2Owner1Type2;
  62
  63     private CapabilityDefinition prevCapName1Owner1Type1;
  64     private CapabilityDefinition prevCapName1Owner1Type2;
  65     private CapabilityDefinition prevCapName1Owner2Type1;
  66     private CapabilityDefinition prevCapName2Owner1Type2;
  67     private CapabilityDefinition prevCapName1Owner3Type1;
  68     private CapabilityDefinition prevCapName3Owner1Type1;
  69     private CapabilityDefinition prevCapName1Owner1Type3;
  70     CapabilityDefinition[] prevCapabilities;
  71     private ComponentInstance oldInstance;
  72     private ComponentInstance currInstance;
  73
  74
  75     @Before
  76     public void setUp() {
  77         capName1Owner1Type1 = new CapabilityDefinitionBuilder().setName("name1").setOwnerId(NEW_OWNER_ID1).setType("type1").build();
  78         prevCapName1Owner1Type1 = new CapabilityDefinition(capName1Owner1Type1);
  79         prevCapName1Owner1Type1.setOwnerId(OLD_OWNER_ID1);
  80
  81         capName1Owner1Type2 = new CapabilityDefinitionBuilder().setName("name1").setOwnerId(NEW_OWNER_ID1).setType("type2").build();
  82         prevCapName1Owner1Type2 = new CapabilityDefinition(capName1Owner1Type2);
  83         prevCapName1Owner1Type2.setOwnerId(OLD_OWNER_ID1);
  84
  85         capName1Owner2Type1 = new CapabilityDefinitionBuilder().setName("name1").setOwnerId(NEW_OWNER_ID2).setType("type1").build();
  86         prevCapName1Owner2Type1 = new CapabilityDefinition(capName1Owner2Type1);
  87         prevCapName1Owner2Type1.setOwnerId(OLD_OWNER_ID2);
  88
  89         capName2Owner1Type2 = new CapabilityDefinitionBuilder().setName("name2").setOwnerId(NEW_OWNER_ID1).setType("type2").build();
  90         prevCapName2Owner1Type2 = new CapabilityDefinition(capName2Owner1Type2);
  91         prevCapName2Owner1Type2.setOwnerId(OLD_OWNER_ID1);
  92
  93         //prev capabilities that are not mapped to any new capability
  94         prevCapName1Owner3Type1 = new CapabilityDefinitionBuilder().setName("name1").setOwnerId(OLD_OWNER_ID3).setType("type1").build();
  95         prevCapName3Owner1Type1 = new CapabilityDefinitionBuilder().setName("name3").setOwnerId(OLD_OWNER_ID1).setType("type1").build();
  96         prevCapName1Owner1Type3 = new CapabilityDefinitionBuilder().setName("name1").setOwnerId(OLD_OWNER_ID1).setType("type3").build();
  97
  98         currInstance = new ComponentInstanceBuilder().setId("inst1").addCapabilities(capName1Owner1Type1, capName1Owner1Type2, capName1Owner2Type1, capName2Owner1Type2).build();
  99         prevCapabilities = new CapabilityDefinition[]{prevCapName1Owner1Type1, prevCapName1Owner1Type2, prevCapName1Owner2Type1, prevCapName2Owner1Type2, prevCapName1Owner3Type1, prevCapName3Owner1Type1, prevCapName1Owner1Type3};
 100         oldInstance = new ComponentInstanceBuilder().setId("inst1").addCapabilities(prevCapabilities).build();
 101     }
 102
 103     @Test
 104     public void resolvePrevCapIdToNewCapability_resolveByTypeNameAndNewOwnerId() {
 105         when(MergeInstanceUtils.mapOldToNewCapabilitiesOwnerIds(oldInstance, currInstance)).thenReturn(ImmutableMap.of(OLD_OWNER_ID1, NEW_OWNER_ID1, OLD_OWNER_ID2, NEW_OWNER_ID2));
 106         Map<CapabilityDefinition, CapabilityDefinition> oldToNewMap = testInstance.resolvePrevCapIdToNewCapability(oldInstance, currInstance);
 107         assertThat(oldToNewMap).hasSize(4);
 108         assertThat(oldToNewMap).containsEntry(prevCapName1Owner1Type1, capName1Owner1Type1);
 109         assertThat(oldToNewMap).containsEntry(prevCapName1Owner1Type2, capName1Owner1Type2);
 110         assertThat(oldToNewMap).containsEntry(prevCapName1Owner2Type1, capName1Owner2Type1);
 111         assertThat(oldToNewMap).containsEntry(prevCapName2Owner1Type2, capName2Owner1Type2);
 112     }
 113
 114     @Test
 115     public void resolvePrevCapIdToNewCapability_noMatchingNewOwnerIds() {
 116         when(MergeInstanceUtils.mapOldToNewCapabilitiesOwnerIds(oldInstance, currInstance)).thenReturn(emptyMap());
 117         Map<CapabilityDefinition, CapabilityDefinition> oldToNewMap = testInstance.resolvePrevCapIdToNewCapability(oldInstance, currInstance);
 118         assertThat(oldToNewMap).isEmpty();
 119     }
 120
 121     @Test
 122     public void mapOldToNewInstanceCapabilitiesOwnerIds() {
 123         Resource container = new ResourceBuilder().addComponentInstance(currInstance).build();
 124         Resource prevInstanceOrigNode = new Resource();
 125         when(MergeInstanceUtils.mapOldToNewCapabilitiesOwnerIds(container, prevInstanceOrigNode, "inst1", asList(OLD_OWNER_ID1, OLD_OWNER_ID2, OLD_OWNER_ID3))).thenReturn(ImmutableMap.of(OLD_OWNER_ID1, NEW_OWNER_ID1, OLD_OWNER_ID2, NEW_OWNER_ID2));
 126         Map<CapabilityDefinition, CapabilityDefinition> oldToNewMap = testInstance.resolvePrevCapToNewCapability(container, prevInstanceOrigNode, "inst1", asList(prevCapabilities));
 127         assertThat(oldToNewMap).hasSize(4);
 128         assertThat(oldToNewMap).containsEntry(prevCapName1Owner1Type1, capName1Owner1Type1);
 129         assertThat(oldToNewMap).containsEntry(prevCapName1Owner1Type2, capName1Owner1Type2);
 130         assertThat(oldToNewMap).containsEntry(prevCapName1Owner2Type1, capName1Owner2Type1);
 131         assertThat(oldToNewMap).containsEntry(prevCapName2Owner1Type2, capName2Owner1Type2);
 132     }
 133 }