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