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

   1 /*
   2  * Copyright © 2016-2018 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
  17 package org.openecomp.sdc.be.tosca.utils;
  18
  19 import static org.junit.jupiter.api.Assertions.assertEquals;
  20 import static org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil.FORWARDER;
  21 import static org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil.FORWARDS_TO_TOSCA_NAME;
  22 import static org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil.PORTS_RANGE;
  23 import static org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil.PROTOCOL;
  24 import static org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil.addForwardingPaths;
  25
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import org.junit.jupiter.api.Assertions;
  33 import org.junit.jupiter.api.BeforeAll;
  34 import org.junit.jupiter.api.BeforeEach;
  35 import org.junit.jupiter.api.Test;
  36 import org.openecomp.sdc.be.components.path.BaseForwardingPathTest;
  37 import org.openecomp.sdc.be.config.ConfigurationManager;
  38 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  39 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  40 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  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.Resource;
  45 import org.openecomp.sdc.be.model.Service;
  46 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
  47 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
  48 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  49 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  50 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
  51
  52 @SpringJUnitConfig(locations = "classpath:paths/path-context.xml")
  53 public class ForwardingPathToscaUtilTest extends BaseForwardingPathTest {
  54
  55     private static final String NODE_NAME_1 = "nodeA-name";
  56     private static final String NODE_NAME_2 = "nodeB-name";
  57     private static final String PATH_1_PROTOCOL = "protocol-path1";
  58     private static final String PATH_1_DESC = "path1-desc";
  59     private static final String PATH_1_PORTS = "8585";
  60     private static final String PATH_1_NAME = "pathName1";
  61     private static final String NODE_ID_1 = "nodeA-id";
  62     private static final String NODE_ID_2 = "nodeB-id";
  63     private static final String FORWARDING_PATH_TOSCA_TYPE = "org.openecomp.nodes.ForwardingPath";
  64     private Service service;
  65     private Map<String, Component> originComponents = new HashMap<>();
  66
  67     @BeforeAll
  68     private static void setup() {
  69         configurationManager =
  70             new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"));
  71     }
  72
  73     @BeforeEach
  74     public void setUpForwardingPath() {
  75         service = initForwardPath();
  76         List<ComponentInstance> componentInstances = new ArrayList<>();
  77         componentInstances.add(generateComponentInstance(NODE_NAME_1, NODE_ID_1));
  78         componentInstances.add(generateComponentInstance(NODE_NAME_2, NODE_ID_2));
  79         service.setComponentInstances(componentInstances);
  80     }
  81
  82     private ComponentInstance generateComponentInstance(String name, String uuid) {
  83         ComponentInstance componentInstance = new ComponentInstance();
  84         componentInstance.setName(name);
  85         componentInstance.setUniqueId(uuid);
  86         componentInstance.setComponentUid(uuid);
  87         Map<String, List<CapabilityDefinition>> capabiltiesMap = new HashMap<>();
  88         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
  89         capabilityDefinition.setMinOccurrences(Integer.toString(1));
  90         capabilityDefinition.setMaxOccurrences(Integer.toString(100));
  91         capabilityDefinition.setType(ForwardingPathToscaUtil.FORWARDS_TO_TOSCA_NAME);
  92         capabilityDefinition.setName(name);
  93         capabilityDefinition.setUniqueId(name);
  94         capabilityDefinition.setPath(Arrays.asList("Just", "something", "to", "read"));
  95         capabiltiesMap.put(capabilityDefinition.getName(), Collections.singletonList(capabilityDefinition));
  96         componentInstance.setCapabilities(capabiltiesMap);
  97         Resource resource = new Resource();
  98         resource.setToscaResourceName("test");
  99         originComponents.put(uuid, resource);
 100         return componentInstance;
 101     }
 102
 103     @Test
 104     public void singleElementPath() {
 105         Assertions.assertDoesNotThrow(() -> {
 106             createPathSingleElement();
 107             Map<String, ToscaNodeTemplate> nodeTemplatesRes = new HashMap<>();
 108
 109             Map<String, ToscaNodeTemplate> expectedNodeTemplatesRes = new HashMap<>();
 110             ToscaNodeTemplate pathEntry = new ToscaNodeTemplate();
 111             pathEntry.setType(FORWARDING_PATH_TOSCA_TYPE);
 112             Map<String, Object> expectedProps = new HashMap<>();
 113             expectedProps.put(PORTS_RANGE, Collections.singletonList(PATH_1_PORTS));
 114             expectedProps.put(PROTOCOL, PATH_1_PROTOCOL);
 115             pathEntry.setProperties(expectedProps);
 116             List<Map<String, ToscaTemplateRequirement>> requirements = new ArrayList<>();
 117             ToscaTemplateRequirement firstEntryReq = new ToscaTemplateRequirement();
 118             ToscaTemplateRequirement secondEntryReq = new ToscaTemplateRequirement();
 119
 120             firstEntryReq.setCapability("null." + NODE_NAME_1);
 121             secondEntryReq.setCapability("null." + NODE_NAME_2);
 122
 123             firstEntryReq.setNode(NODE_NAME_1);
 124             secondEntryReq.setNode(NODE_NAME_2);
 125
 126             firstEntryReq.setRelationship(FORWARDS_TO_TOSCA_NAME);
 127             secondEntryReq.setRelationship(FORWARDS_TO_TOSCA_NAME);
 128
 129             Map<String, ToscaTemplateRequirement> entryMap1 = new HashMap<>();
 130             Map<String, ToscaTemplateRequirement> entryMap2 = new HashMap<>();
 131
 132             entryMap1.put(FORWARDER, firstEntryReq);
 133             entryMap2.put(FORWARDER, secondEntryReq);
 134
 135             requirements.add(entryMap1);
 136             requirements.add(entryMap2);
 137
 138             pathEntry.setRequirements(requirements);
 139             expectedNodeTemplatesRes.put(PATH_1_NAME, pathEntry);
 140             addForwardingPaths(service, nodeTemplatesRes, capabiltyRequirementConvertor, originComponents, toscaOperationFacade);
 141
 142             assertEquals(2, nodeTemplatesRes.get(PATH_1_NAME).getRequirements().size());
 143             compareToscaPathEntry(expectedNodeTemplatesRes, nodeTemplatesRes);
 144         });
 145     }
 146
 147     private void compareToscaPathEntry(Map<String, ToscaNodeTemplate> expectedNodeTemplatesRes,
 148                                        Map<String, ToscaNodeTemplate> nodeTemplatesRes) {
 149         final ToscaNodeTemplate expectedTemplate = expectedNodeTemplatesRes.get(PATH_1_NAME);
 150         final ToscaNodeTemplate actualTemplate = nodeTemplatesRes.get(PATH_1_NAME);
 151         assertEquals(expectedTemplate.getProperties(), actualTemplate.getProperties());
 152         final int size = expectedTemplate.getRequirements().size();
 153         assertEquals(size, actualTemplate.getRequirements().size());
 154         for (int i = 0; i < size; i++) {
 155             compareToscaRequirement(expectedTemplate, actualTemplate, i);
 156         }
 157     }
 158
 159     private void compareToscaRequirement(ToscaNodeTemplate expectedTemplate,
 160                                          ToscaNodeTemplate actualTemplate,
 161                                          int i) {
 162         final ToscaTemplateRequirement actualRequirement = actualTemplate.getRequirements().get(i).get(FORWARDER);
 163         final ToscaTemplateRequirement expectedToscaRequirement = expectedTemplate.getRequirements().get(i).get(FORWARDER);
 164         assertEquals(actualRequirement.getCapability(), expectedToscaRequirement.getCapability());
 165         assertEquals(actualRequirement.getNode(), expectedToscaRequirement.getNode());
 166     }
 167
 168     private void createPathSingleElement() {
 169         ForwardingPathElementDataDefinition element1 = initElement(NODE_NAME_1, NODE_NAME_2, NODE_NAME_1, NODE_NAME_2);
 170
 171         ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
 172         list.add(element1);
 173
 174         ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
 175         path.setDescription(PATH_1_DESC);
 176         path.setProtocol(PATH_1_PROTOCOL);
 177         path.setDestinationPortNumber(PATH_1_PORTS);
 178         path.setToscaResourceName(FORWARDING_PATH_TOSCA_TYPE);
 179         path.setPathElements(list);
 180         path.setName(PATH_1_NAME);
 181
 182         Map<String, ForwardingPathDataDefinition> paths = new HashMap<>();
 183         paths.put(PATH_1_NAME, path);
 184
 185         service.setForwardingPaths(paths);
 186     }
 187
 188     private ForwardingPathElementDataDefinition initElement(String fromId, String toId, String fromCP, String toCP) {
 189         ForwardingPathElementDataDefinition element = new ForwardingPathElementDataDefinition();
 190         element.setFromCP(fromCP);
 191         element.setFromNode(fromId);
 192         element.setToCP(toCP);
 193         element.setToNode(toId);
 194         return element;
 195     }
 196 }