catalog-be/src/test/java/org/openecomp/sdc/be/components/path/ForwardingPathToscaUtilTest.java

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