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