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