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

   1 package org.openecomp.sdc.be.components;
   2
   3 import com.fasterxml.jackson.databind.ObjectMapper;
   4 import com.google.gson.Gson;
   5 import com.google.gson.GsonBuilder;
   6 import fj.data.Either;
   7 import org.junit.Test;
   8 import org.mockito.Mockito;
   9 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  10 import org.openecomp.sdc.be.datamodel.ServiceRelations;
  11 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  12 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  13 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  14 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  15 import org.openecomp.sdc.be.impl.ComponentsUtils;
  16 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
  17 import org.openecomp.sdc.be.model.*;
  18 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  19 import org.openecomp.sdc.exception.ResponseFormat;
  20
  21 import java.io.IOException;
  22 import java.util.*;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertTrue;
  26
  27 public class PathTest extends BaseServiceBusinessLogicTest {
  28     public static final String fromNode = "fromNode";
  29
  30     @Override
  31     protected Service createServiceObject(boolean afterCreate) {
  32         Service service = super.createServiceObject(afterCreate);
  33         ArrayList<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
  34         String toNode = "toNode";
  35         resourceInstancesRelations.add(createRequirementCapabilityRelDef(fromNode, toNode));
  36         String fromNode1 = "fromNode1";
  37         String toNode1 = "toNode1";
  38         resourceInstancesRelations.add(createRequirementCapabilityRelDef(fromNode1, toNode1));
  39         service.setComponentInstances(new java.util.ArrayList<>());
  40         service.getComponentInstances().add(getComponentInstance(fromNode, "fromNode"));
  41         service.getComponentInstances().add(getComponentInstance(fromNode1, "fromNode1"));
  42         service.getComponentInstances().add(getComponentInstance(toNode, toNode));
  43         service.getComponentInstances().add(getComponentInstance(toNode1, toNode1));
  44
  45        service.setComponentInstancesRelations(resourceInstancesRelations);
  46         return service;
  47     }
  48
  49     private ComponentInstance getComponentInstance(String uniquId, String normalizedName) {
  50         ComponentInstance ci = new ComponentInstance();
  51         ci.setUniqueId(uniquId);
  52         ci.setNormalizedName(normalizedName);
  53         ci.setName(normalizedName);
  54         HashMap<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
  55         CapabilityDefinition capabilityDefinition = getCapabilityDefinition(ci);
  56         capabilities.put(capabilityDefinition.getUniqueId(), Arrays.asList(capabilityDefinition));
  57         capabilityDefinition = getCapabilityDefinition(ci);
  58         capabilities.put(capabilityDefinition.getUniqueId(), Arrays.asList(capabilityDefinition));
  59         ci.setCapabilities(capabilities);
  60         return ci;
  61     }
  62
  63     private static int i = 0;
  64
  65     private CapabilityDefinition getCapabilityDefinition(ComponentInstance ci) {
  66         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
  67         capabilityDefinition.setUniqueId(UUID.randomUUID().toString());
  68         capabilityDefinition.setName("My name " + i++);
  69         capabilityDefinition.setType(ForwardingPathUtils.FORWARDER_CAPABILITY);
  70         capabilityDefinition.setOwnerId(ci.getUniqueId());
  71         return capabilityDefinition;
  72     }
  73
  74
  75     protected RequirementCapabilityRelDef createRequirementCapabilityRelDef(String fromNode, String toNode) {
  76         RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
  77         requirementCapabilityRelDef.setFromNode(fromNode);
  78         requirementCapabilityRelDef.setRelationships(new ArrayList<>());
  79         CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
  80         RelationshipImpl relationship = new RelationshipImpl();
  81         relationship.setType("something.LINK");
  82         requirementCapabilityRelDef.getRelationships().add(capabilityRequirementRelationship);
  83         requirementCapabilityRelDef.setToNode(toNode);
  84         return requirementCapabilityRelDef;
  85     }
  86
  87     @Test
  88     public void validateSerialization() throws IOException {
  89         Service service = new Service();
  90         ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition("Name");
  91         String protocol = "protocol";
  92         forwardingPath.setProtocol(protocol);
  93         forwardingPath.setDestinationPortNumber("DestinationPortNumber");
  94         ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = new ListDataDefinition<>();
  95         String nodeA = "nodeA";
  96         forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition(nodeA, "nodeB", "nodeAcpType", "nodeBcpType", "nodeDcpName", "nodeBcpName"));
  97         forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition("nodeB", "nodeC", "nodeBcpType", "nodeCcpType", "nodeDcpName", "nodeBcpName"));
  98         forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition("nodeC", "nodeD", "nodeCcpType", "nodeDcpType", "nodeDcpName", "nodeBcpName"));
  99         forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 100         Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 101         forwardingPaths.put("NEW", forwardingPath);
 102         service.setForwardingPaths(forwardingPaths);
 103         ObjectMapper mapper = new ObjectMapper();
 104         String jsonResult = mapper.writerWithDefaultPrettyPrinter()
 105                 .writeValueAsString(service);
 106         System.out.println(jsonResult);
 107
 108         Either<Service, ResponseFormat> serviceResponseFormatEither = new ComponentsUtils(Mockito.mock(AuditingManager.class)).convertJsonToObjectUsingObjectMapper(jsonResult, user, Service.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);
 109         assertTrue(serviceResponseFormatEither.isLeft());
 110         Map<String, ForwardingPathDataDefinition> paths = serviceResponseFormatEither.left().value().getForwardingPaths();
 111         assertEquals(paths.size(), 1);
 112         ForwardingPathDataDefinition forwardingPathDataDefinition = paths.values().stream().findAny().get();
 113         assertEquals(protocol, forwardingPathDataDefinition.getProtocol());
 114         List<ForwardingPathElementDataDefinition> listToscaDataDefinition = forwardingPathDataDefinition.getPathElements().getListToscaDataDefinition();
 115         assertEquals(3, listToscaDataDefinition.size());
 116         assertEquals(listToscaDataDefinition.get(0).getFromNode(), nodeA);
 117     }
 118
 119     @Test
 120     public void shouldReturnEmptyRelationsObjectsWhenNoComponentInstanceExist() {
 121         ServiceRelations serviceRelations = new ForwardingPathUtils().convertServiceToServiceRelations(super.createServiceObject(false));
 122         assertTrue(serviceRelations.isEmpty());
 123     }
 124
 125     @Test
 126     public void convertServiceToServiceRelations() {
 127         ServiceRelations serviceRelations = new ForwardingPathUtils().convertServiceToServiceRelations(createServiceObject(false));
 128         Gson gson = new GsonBuilder().setPrettyPrinting().create();
 129         String resultString = gson.toJson(serviceRelations);
 130         System.out.println(" RESPONSE BODY: " + resultString);
 131         assertTrue(resultString.contains(fromNode));
 132     }
 133
 134     @Test
 135     public void emptyCapabilitesShouldNotCauseFailure() {
 136         Service serviceObject = createServiceObject(false);
 137         ComponentInstance ci = new ComponentInstance();
 138         ci.setCapabilities(null);
 139         serviceObject.getComponentInstances().add(ci);
 140         ServiceRelations serviceRelations = new ForwardingPathUtils().convertServiceToServiceRelations(
 141             serviceObject);
 142         Gson gson = new GsonBuilder().setPrettyPrinting().create();
 143         String resultString = gson.toJson(serviceRelations);
 144         System.out.println(" RESPONSE BODY: " + resultString);
 145         assertTrue(resultString.contains(fromNode));
 146     }
 147 }