catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java

   1 /*
   2  * Copyright © 2016-2019 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openecomp.sdc.be.tosca;
  17
  18 import com.google.common.collect.ImmutableList;
  19 import fj.data.Either;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.junit.runner.RunWith;
  23 import org.mockito.InjectMocks;
  24 import org.mockito.Mock;
  25 import org.mockito.Mockito;
  26 import org.mockito.Spy;
  27 import org.mockito.junit.MockitoJUnitRunner;
  28
  29 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  30 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  31 import org.openecomp.sdc.be.model.CapabilityDefinition;
  32 import org.openecomp.sdc.be.model.Component;
  33 import org.openecomp.sdc.be.model.ComponentInstance;
  34 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  35 import org.openecomp.sdc.be.model.ComponentParametersView;
  36 import org.openecomp.sdc.be.model.GroupDefinition;
  37 import org.openecomp.sdc.be.model.RequirementDefinition;
  38 import org.openecomp.sdc.be.model.Resource;
  39 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  40 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
  41 import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
  42
  43 import java.util.ArrayList;
  44 import java.util.Collections;
  45 import java.util.HashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.stream.Collectors;
  49
  50 import static org.assertj.core.api.Assertions.assertThat;
  51 import static org.junit.Assert.assertEquals;
  52 import static org.junit.Assert.assertFalse;
  53 import static org.junit.Assert.assertNotNull;
  54 import static org.junit.Assert.assertTrue;
  55 import static org.mockito.ArgumentMatchers.any;
  56 import static org.mockito.ArgumentMatchers.eq;
  57 import static org.mockito.Mockito.when;
  58
  59 @RunWith(MockitoJUnitRunner.class)
  60 public class CapabilityRequirementConverterTest {
  61
  62     @Mock
  63     private ToscaOperationFacade toscaOperationFacade;
  64     @Mock
  65     private PropertyConvertor propertyConvertor;
  66
  67     @InjectMocks
  68     private CapabilityRequirementConverter capabilityRequirementConverter;
  69
  70     @Spy
  71     private ComponentInstance instanceProxy = new ComponentInstance();
  72     @Spy
  73     private ComponentInstance vfInstance = new ComponentInstance();
  74     @Spy
  75     private Component vfComponent = new Resource();
  76     @Spy
  77     private ComponentInstance vfcInstance = new ComponentInstance();
  78     @Spy
  79     private Component vfcComponent = new Resource();
  80
  81     private static final String VF_INSTANCE_NAME = "vepdgtp4837vf0";
  82     private static final String VF_INSTANCE_NORMALIZED_NAME = "vepdgtp4837vf0";
  83     private static final String VF_INSTANCE_UNIQUE_ID = "5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0";
  84     private static final String VF_COMPONENT_NAME = "vepdgtp4837vf0";
  85
  86     private static final String VFC_INSTANCE_UNIQUE_ID = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
  87     private static final String VFC_INSTANCE_NAME = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
  88     private static final String VFC_INSTANCE_NORMALIZED_NAME = "lb_1";
  89     private static final String VFC_COMPONENT_NAME = "clb_1";
  90
  91     private static final String ORIGIN_NAME = "vepdgtp4837svc_proxy0";
  92
  93     private static final String OWNER_ID = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693";
  94     private static final String DATA_DEFINITION_NAME = "name";
  95
  96     private static final String GROUP_NAME = "groupName";
  97
  98     private static final String PROPERTY_VALUE = "propValue";
  99     private static final String PROPERTY_NAME = "propName";
 100
 101     @Before
 102     public void clean() {
 103         instanceProxy = Mockito.spy(new ComponentInstance());
 104         vfInstance = Mockito.spy(new ComponentInstance());
 105         vfcInstance = Mockito.spy(new ComponentInstance());
 106         vfComponent = Mockito.spy(new Resource());
 107         vfcComponent = Mockito.spy(new Resource());
 108     }
 109
 110     @Test
 111     public void testGetInstance() {
 112         assertNotNull(CapabilityRequirementConverter.getInstance());
 113     }
 114
 115     @Test
 116     public void testGetReducedPathByOwner() {
 117         List<String> pathList = new ArrayList<>();
 118         String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
 119
 120         String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
 121         pathList.add(VFC_INSTANCE_UNIQUE_ID);
 122         pathList.add(duplicate);
 123         pathList.add(duplicate);
 124         pathList.add(uniqueId);
 125
 126         pathList.add(VF_INSTANCE_UNIQUE_ID);
 127         pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 128
 129         List<String> reducedMap = new CapabilityRequirementConverter().getReducedPathByOwner(pathList, uniqueId);
 130
 131         assertThat(reducedMap).isNotNull().doesNotContain(VFC_INSTANCE_UNIQUE_ID)
 132                 .containsOnlyOnce(duplicate).hasSize(4);
 133
 134         List<String> path = new ArrayList<>();
 135         capabilityRequirementConverter.getReducedPathByOwner(path, uniqueId);
 136
 137         path.add("");
 138         capabilityRequirementConverter.getReducedPathByOwner(path, uniqueId);
 139         capabilityRequirementConverter.getReducedPathByOwner(path, "");
 140     }
 141
 142     @Test
 143     public void testBuildName() {
 144         // endregion
 145         Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
 146         Component origin = getOrigin(vfInstance);
 147         Map<String, Component> cache = populateInstanceAndGetCache(origin, capabilities);
 148
 149         List<CapabilityDefinition> flatList = capabilities.values().stream().flatMap(List::stream)
 150                 .collect(Collectors.toList());
 151         flatList.forEach((CapabilityDefinition capabilityDefinition) -> {
 152             String name = capabilityRequirementConverter.buildCapabilityNameForComponentInstance(cache, instanceProxy,
 153                     capabilityDefinition);
 154             assertThat(name).isEqualTo(VF_INSTANCE_NAME + "." +
 155                     VFC_INSTANCE_NORMALIZED_NAME + "." + capabilityDefinition.getName());
 156         });
 157     }
 158
 159     @Test
 160     public void getReducedPathByOwner() {
 161         List<String> pathList = new ArrayList<>();
 162         String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
 163
 164         String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
 165         pathList.add(VFC_INSTANCE_UNIQUE_ID);
 166         pathList.add(duplicate);
 167         pathList.add(duplicate);
 168         pathList.add(uniqueId);
 169
 170         pathList.add(VF_INSTANCE_UNIQUE_ID);
 171         pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 172
 173         List<String> reducedMap = new CapabilityRequirementConverter().getReducedPathByOwner(pathList, uniqueId);
 174
 175         assertThat(reducedMap).isNotNull().doesNotContain(VFC_INSTANCE_UNIQUE_ID)
 176                 .containsOnlyOnce(duplicate).hasSize(4);
 177     }
 178
 179     @Test
 180     public void testConvertSubstitutionMappingCapabilities() {
 181         String capabilityName = "port";
 182         // endregion
 183         Map<String, List<CapabilityDefinition>> capabilities = newCapabilities(capabilityName);
 184         Component origin = getOrigin(vfcInstance);
 185         Map<String, Component> cache = populateInstanceAndGetCache(origin, capabilities);
 186         Either<Map<String, String[]>, ToscaError> res = capabilityRequirementConverter
 187                 .convertSubstitutionMappingCapabilities(cache, origin);
 188
 189         assertFalse(res.isRight());
 190         assertTrue(res.isLeft());
 191         Map<String, String[]> map = res.left().value();
 192         String[] substitution = map.get(VFC_INSTANCE_NORMALIZED_NAME + "." + capabilityName);
 193         assertEquals(VFC_INSTANCE_UNIQUE_ID, substitution[0]);
 194         assertEquals(capabilityName, substitution[1]);
 195     }
 196
 197     @Test
 198     public void buildRequirementNameForComponentInstanceTest() {
 199         String capabilityName = "port";
 200         // endregion
 201         Map<String, List<CapabilityDefinition>> capabilities = newCapabilities(capabilityName);
 202         Component origin = getOrigin(vfcInstance);
 203         Map<String, Component> cache = populateInstanceAndGetCache(origin, capabilities);
 204
 205         RequirementDefinition def = getRequirementDefinition();
 206
 207         String resp = capabilityRequirementConverter.buildRequirementNameForComponentInstance(cache, vfcInstance, def);
 208         assertEquals(DATA_DEFINITION_NAME, resp);
 209     }
 210
 211     @Test
 212     public void convertComponentInstanceCapabilitiesTest() {
 213         vfcInstance.setUniqueId(VFC_INSTANCE_UNIQUE_ID);
 214         vfcInstance.setName(VFC_INSTANCE_NAME);
 215         vfcInstance.setNormalizedName(VFC_INSTANCE_NORMALIZED_NAME);
 216
 217         Component origin = getOrigin(vfcInstance);
 218         GroupDefinition group = new GroupDefinition();
 219         group.setUniqueId("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 220         group.setName(GROUP_NAME);
 221         origin.setGroups(ImmutableList.of(group));
 222
 223         when(toscaOperationFacade.getToscaElement(any(), any(ComponentParametersView.class)))
 224                 .thenReturn(Either.left(origin));
 225
 226         when(propertyConvertor.convertToToscaObject(any(ComponentInstanceProperty.class),
 227                 eq(PROPERTY_VALUE), any(), eq(false))).thenReturn(PROPERTY_VALUE);
 228
 229         String capabilityName = "port";
 230         // endregion
 231         Map<String, List<CapabilityDefinition>> capabilities = newCapabilities(capabilityName);
 232         vfcInstance.setCapabilities(capabilities);
 233
 234         ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
 235
 236         Either<ToscaNodeTemplate, ToscaError> resp = capabilityRequirementConverter.convertComponentInstanceCapabilities(vfcInstance,
 237                 new HashMap<>(), nodeTemplate);
 238
 239         assertTrue(resp.isLeft());
 240         assertFalse(resp.isRight());
 241
 242         Map<String, ToscaTemplateCapability> convertCapabilities = resp.left().value().getCapabilities();
 243         assertNotNull(convertCapabilities.get(GROUP_NAME + "." + capabilityName));
 244
 245         ToscaTemplateCapability templateCapability = convertCapabilities.get("groupName.port");
 246         assertEquals(PROPERTY_VALUE, templateCapability.getProperties().get(PROPERTY_NAME));
 247     }
 248
 249     private Component getOrigin(ComponentInstance instance) {
 250         // region proxy
 251         Component proxyOrigin = new Resource();
 252
 253         proxyOrigin.setName(ORIGIN_NAME);
 254         proxyOrigin.setComponentType(ComponentTypeEnum.RESOURCE);
 255         proxyOrigin.setComponentInstances(Collections.singletonList(instance));
 256         return proxyOrigin;
 257     }
 258
 259     private Map<String, Component> populateInstanceAndGetCache(Component proxyOrigin,
 260                                                               Map<String, List<CapabilityDefinition>> capabilities) {
 261         when(instanceProxy.getActualComponentUid()).thenReturn("1");
 262         when(vfInstance.getActualComponentUid()).thenReturn("2");
 263         when(vfcInstance.getActualComponentUid()).thenReturn("3");
 264
 265         // endregion
 266         // region vf+vfc
 267         vfInstance.setName(VF_INSTANCE_NAME);
 268         vfInstance.setNormalizedName(VF_INSTANCE_NORMALIZED_NAME);
 269         vfInstance.setUniqueId(VF_INSTANCE_UNIQUE_ID);
 270
 271         vfComponent.setName(VF_COMPONENT_NAME); // origin
 272         vfComponent.setComponentInstances(Collections.singletonList(vfcInstance));
 273
 274         vfcInstance.setUniqueId(VFC_INSTANCE_UNIQUE_ID);
 275         vfcInstance.setName(VFC_INSTANCE_NAME);
 276         vfcInstance.setNormalizedName(VFC_INSTANCE_NORMALIZED_NAME);
 277
 278         vfcComponent.setName(VFC_COMPONENT_NAME);
 279
 280         vfcComponent.setCapabilities(capabilities);
 281         instanceProxy.setCapabilities(capabilities);
 282         proxyOrigin.setCapabilities(capabilities);
 283
 284         return Collections.unmodifiableMap(new HashMap<String, Component>() {
 285             {
 286                 put("1", proxyOrigin);
 287                 put("2", vfComponent);
 288                 put("3", vfcComponent);
 289             }
 290         });
 291     }
 292
 293     private RequirementDefinition getRequirementDefinition() {
 294         RequirementDataDefinition dataDefinition = new RequirementDataDefinition();
 295         dataDefinition.setName(DATA_DEFINITION_NAME);
 296         dataDefinition.setPreviousName("previousName");
 297         dataDefinition.setOwnerId(OWNER_ID);
 298         dataDefinition.setPath(getPath());
 299
 300         return new RequirementDefinition(dataDefinition);
 301     }
 302
 303     // generate stub capability
 304     private Map<String, List<CapabilityDefinition>> newCapabilities(String capabilityName) {
 305         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 306         List<CapabilityDefinition> list = new ArrayList<>();
 307         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 308         capabilityDefinition.setName(capabilityName);
 309         capabilityDefinition.setType("att.Node");
 310         capabilityDefinition.setExternal(true);
 311         List<ComponentInstanceProperty> properties = new ArrayList<>();
 312         ComponentInstanceProperty prop = new ComponentInstanceProperty();
 313         prop.setName(PROPERTY_NAME);
 314         prop.setValue(PROPERTY_VALUE);
 315         properties.add(prop);
 316         capabilityDefinition.setProperties(properties);
 317         capabilityDefinition.setOwnerId(OWNER_ID);
 318
 319         List<String> pathList = getPath();
 320         capabilityDefinition.setPath(pathList);
 321         list.add(capabilityDefinition);
 322         capabilities.put(capabilityDefinition.getType(), list);
 323
 324         return capabilities;
 325     }
 326
 327     private List<String> getPath() {
 328         List<String> path = new ArrayList<>();
 329         path.add(VFC_INSTANCE_UNIQUE_ID);
 330         // pathList.add("a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi");
 331         path.add(VF_INSTANCE_UNIQUE_ID);
 332         path.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 333
 334         return path;
 335     }
 336
 337 }