test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/interfaceoperation/InterfaceOperationsTest.java

   1 package org.openecomp.sdc.ci.tests.execute.interfaceoperation;
   2
   3 import static org.testng.AssertJUnit.fail;
   4
   5 import com.fasterxml.jackson.annotation.JsonInclude;
   6 import com.fasterxml.jackson.databind.ObjectMapper;
   7 import fj.data.Either;
   8 import java.util.HashMap;
   9 import java.util.Map;
  10 import org.junit.Rule;
  11 import org.junit.rules.TestName;
  12 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  13 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  14 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
  15 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  16 import org.openecomp.sdc.be.model.InputDefinition;
  17 import org.openecomp.sdc.be.model.InterfaceDefinition;
  18 import org.openecomp.sdc.be.model.Operation;
  19 import org.openecomp.sdc.be.model.PropertyDefinition;
  20 import org.openecomp.sdc.be.model.Resource;
  21 import org.openecomp.sdc.be.model.Service;
  22 import org.openecomp.sdc.be.model.User;
  23 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  24 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  25 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  26 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  27 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  28 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  29 import org.openecomp.sdc.ci.tests.utils.rest.InterfaceOperationsRestUtils;
  30 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  31 import org.testng.Assert;
  32 import org.testng.annotations.BeforeClass;
  33 import org.testng.annotations.Test;
  34
  35 public class InterfaceOperationsTest extends ComponentBaseTest {
  36
  37     @Rule
  38     private static final TestName name = new TestName();
  39     private static final String INTERFACES = "interfaces";
  40     private static final String TOSCA_PRESENTATION = "toscaPresentation";
  41     private static final User user = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  42
  43     private static Service service;
  44     private static Resource resource;
  45     private String resourceInterfaceUniqueId;
  46     private String resourceOperationUniqueId;
  47     private String serviceInterfaceUniqueId;
  48     private String serviceOperationUniqueId;
  49
  50     public InterfaceOperationsTest() {
  51         super(name, InterfaceOperationsTest.class.getName());
  52     }
  53
  54     @BeforeClass
  55     public static void init() throws Exception {
  56         // Create default service
  57         Either<Service, RestResponse> createDefaultServiceEither =
  58                 AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
  59         if (createDefaultServiceEither.isRight()) {
  60             fail("Error creating default service");
  61         }
  62         service = createDefaultServiceEither.left().value();
  63
  64         // Create default resource
  65         Either<Resource, RestResponse> createDefaultResourceEither =
  66                 AtomicOperationUtils.createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true);
  67         if (createDefaultResourceEither.isRight()) {
  68             fail("Error creating default resource");
  69         }
  70         resource = createDefaultResourceEither.left().value();
  71     }
  72
  73     private Map<String, Object> buildInterfaceDefinitionForResource() {
  74         Operation operation = new Operation();
  75         operation.setName("TestOperationOnResource");
  76         operation.setWorkflowId("WorkflowId");
  77         operation.setWorkflowVersionId("workflowVersionId");
  78         operation.setWorkflowAssociationType("NONE");
  79         PropertyDefinition property =
  80                 resource.getInputs().stream().filter(a -> a.getName().equalsIgnoreCase("nf_naming")).findFirst()
  81                         .orElse(new InputDefinition());
  82         ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
  83         operationInputDefinitionList.add(createOperationInputDefinition("TestInput1", property.getUniqueId()));
  84         operation.setInputs(operationInputDefinitionList);
  85         ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
  86         operationOutputDefinitionList.add(createOperationOutputDefinition("TestOutput1"));
  87         operation.setOutputs(operationOutputDefinitionList);
  88         return buildInterfaceDefinitionMap(operation, "TestInterface", resourceInterfaceUniqueId, resourceOperationUniqueId);
  89     }
  90
  91     private Map<String, Object> buildInterfaceDefinitionOfGlobalTypeForResource() {
  92         Operation operation = new Operation();
  93         operation.setName("create");
  94         operation.setWorkflowId("WorkflowId");
  95         operation.setWorkflowVersionId("workflowVersionId");
  96         operation.setWorkflowAssociationType("NONE");
  97         PropertyDefinition property =
  98                 resource.getInputs().stream().filter(a -> a.getName().equalsIgnoreCase("nf_naming")).findFirst()
  99                         .orElse(new InputDefinition());
 100         ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
 101         operationInputDefinitionList.add(createOperationInputDefinition("TestInput1", property.getUniqueId()));
 102         operation.setInputs(operationInputDefinitionList);
 103         ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
 104         operationOutputDefinitionList.add(createOperationOutputDefinition("TestOutput1"));
 105         operation.setOutputs(operationOutputDefinitionList);
 106         return buildInterfaceDefinitionMap(operation,"tosca.interfaces.node.lifecycle.Standard", resourceInterfaceUniqueId, resourceOperationUniqueId);
 107     }
 108
 109     private OperationInputDefinition createOperationInputDefinition(String name, String inputId) {
 110         OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
 111         operationInputDefinition.setName(name);
 112         operationInputDefinition.setInputId(inputId);
 113         operationInputDefinition.setRequired(true);
 114         operationInputDefinition.setType("string");
 115         return operationInputDefinition;
 116     }
 117
 118     private OperationOutputDefinition createOperationOutputDefinition(String name) {
 119         OperationOutputDefinition operationOutputDefinition = new OperationOutputDefinition();
 120         operationOutputDefinition.setName(name);
 121         operationOutputDefinition.setRequired(true);
 122         operationOutputDefinition.setType("string");
 123         return operationOutputDefinition;
 124     }
 125
 126     private Map<String, Object> buildInterfaceDefinitionMap(Operation operation, String interfaceType, String interfaceId,
 127             String operationId) {
 128         if (operationId != null) {
 129             operation.setUniqueId(operationId);
 130         }
 131         Map<String, Operation> operationMap = new HashMap<>();
 132         operationMap.put(operation.getName(), operation);
 133
 134         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 135         interfaceDefinition.setType(interfaceType);
 136         interfaceDefinition.setOperationsMap(operationMap);
 137         if (interfaceId != null) {
 138             interfaceDefinition.setUniqueId(interfaceId);
 139         }
 140         interfaceDefinition.setOperationsMap(operationMap);
 141
 142         Map<String, Object> interfaceDefAsMap = getObjectAsMap(interfaceDefinition);
 143         Map<String, Object> interfaceMap = new HashMap<>();
 144         interfaceMap.put(interfaceDefinition.getType(), interfaceDefAsMap);
 145         Map<String, Object> outerMap = new HashMap<>();
 146         outerMap.put(INTERFACES, interfaceMap);
 147         return outerMap;
 148     }
 149
 150     private static Map<String, Object> getObjectAsMap(Object obj) {
 151         ObjectMapper objectMapper = new ObjectMapper();
 152         if (obj instanceof InterfaceDefinition) {
 153             objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 154         }
 155         Map<String, Object> objectAsMap =
 156                 obj instanceof Map ? (Map<String, Object>) obj : objectMapper.convertValue(obj, Map.class);
 157         objectAsMap.remove(TOSCA_PRESENTATION);
 158         return objectAsMap;
 159     }
 160
 161     private Map<String, Object> buildInterfaceDefinitionForService() {
 162         Operation operation = new Operation();
 163         operation.setName("TestOperationOnService");
 164         operation.setWorkflowId("WorkflowId");
 165         operation.setWorkflowVersionId("workflowVersionId");
 166         operation.setWorkflowAssociationType("NONE");
 167         return buildInterfaceDefinitionMap(operation,"TestInterface", serviceInterfaceUniqueId, serviceOperationUniqueId);
 168     }
 169
 170     @Test
 171     public void addInterfaceOperationsOnResource() throws Exception {
 172         RestResponse restResponse = InterfaceOperationsRestUtils
 173                                             .addInterfaceOperations(resource, buildInterfaceDefinitionForResource(),
 174                                                     user);
 175         logger.info("addInterfaceOperationsOnResource Response Code:" + restResponse.getErrorCode());
 176         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 177         String interfaceDefinitionStr = ResponseParser.getListFromJson(restResponse, INTERFACES).get(0).toString();
 178         InterfaceDefinition interfaceDefinition =
 179                 ResponseParser.convertInterfaceDefinitionResponseToJavaObject(interfaceDefinitionStr);
 180         resourceInterfaceUniqueId = interfaceDefinition.getUniqueId();
 181         resourceOperationUniqueId = interfaceDefinition.getOperationsMap().keySet().stream().findFirst().orElse(null);
 182     }
 183
 184     @Test(dependsOnMethods = "addInterfaceOperationsOnResource")
 185     public void getInterfaceOperationsFromResource() throws Exception {
 186         RestResponse restResponse = InterfaceOperationsRestUtils
 187                                             .getInterfaceOperations(resource, resourceInterfaceUniqueId,
 188                                                     resourceOperationUniqueId, user);
 189         logger.info("getInterfaceOperationsFromResource Response Code:" + restResponse.getErrorCode());
 190         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 191     }
 192
 193     @Test(dependsOnMethods = "getInterfaceOperationsFromResource")
 194     public void updateInterfaceOperationsOnResource() throws Exception {
 195         RestResponse restResponse = InterfaceOperationsRestUtils
 196                                             .updateInterfaceOperations(resource, buildInterfaceDefinitionForResource(),
 197                                                     user);
 198         logger.info("updateInterfaceOperationsOnResource Response Code:" + restResponse.getErrorCode());
 199         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 200     }
 201
 202     /*@Test(dependsOnMethods = "updateInterfaceOperationsOnResource")
 203     public void deleteInterfaceOperationsFromResource() throws Exception {
 204         RestResponse restResponse = InterfaceOperationsRestUtils
 205                                             .deleteInterfaceOperations(resource, resourceInterfaceUniqueId,
 206                                                     resourceOperationUniqueId, user);
 207         logger.info("deleteInterfaceOperationsFromResource Response Code:" + restResponse.getErrorCode());
 208         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 209     }*/
 210
 211     @Test
 212     public void addInterfaceOperationsOnService() throws Exception {
 213         RestResponse restResponse = InterfaceOperationsRestUtils
 214                                             .addInterfaceOperations(service, buildInterfaceDefinitionForService(),
 215                                                     user);
 216         logger.info("addInterfaceOperationsOnService Response Code:" + restResponse.getErrorCode());
 217         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 218         String interfaceDefinitionStr = ResponseParser.getListFromJson(restResponse, INTERFACES).get(0).toString();
 219         InterfaceDefinition interfaceDefinition =
 220                 ResponseParser.convertInterfaceDefinitionResponseToJavaObject(interfaceDefinitionStr);
 221         serviceInterfaceUniqueId = interfaceDefinition.getUniqueId();
 222         serviceOperationUniqueId = interfaceDefinition.getOperationsMap().keySet().stream().findFirst().orElse(null);
 223     }
 224
 225     @Test(dependsOnMethods = "addInterfaceOperationsOnService")
 226     public void getInterfaceOperationsFromService() throws Exception {
 227         RestResponse restResponse = InterfaceOperationsRestUtils
 228                                             .getInterfaceOperations(service, serviceInterfaceUniqueId,
 229                                                     serviceOperationUniqueId, user);
 230         logger.info("getInterfaceOperationsFromService Response Code:" + restResponse.getErrorCode());
 231         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 232     }
 233
 234     @Test(dependsOnMethods = "getInterfaceOperationsFromService")
 235     public void updateInterfaceOperationsOnService() throws Exception {
 236         RestResponse restResponse = InterfaceOperationsRestUtils
 237                                             .updateInterfaceOperations(service, buildInterfaceDefinitionForService(),
 238                                                     user);
 239         logger.info("updateInterfaceOperations Response Code:" + restResponse.getErrorCode());
 240         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 241     }
 242
 243     @Test(dependsOnMethods = "updateInterfaceOperationsOnService")
 244     public void deleteInterfaceOperationsFromService() throws Exception {
 245         RestResponse restResponse = InterfaceOperationsRestUtils
 246                                             .deleteInterfaceOperations(service, serviceInterfaceUniqueId,
 247                                                     serviceOperationUniqueId, user);
 248         logger.info("deleteInterfaceOperations Response Code:" + restResponse.getErrorCode());
 249         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 250     }
 251
 252     @Test
 253     public void addInterfaceOperationsOfGlobalTypeOnResource() throws Exception {
 254         RestResponse restResponse = InterfaceOperationsRestUtils
 255                                             .addInterfaceOperations(resource, buildInterfaceDefinitionOfGlobalTypeForResource(),
 256                                                     user);
 257         logger.info("addInterfaceOperationsOnResource Response Code:" + restResponse.getErrorCode());
 258         Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
 259         String interfaceDefinitionStr = ResponseParser.getListFromJson(restResponse, INTERFACES).get(0).toString();
 260         InterfaceDefinition interfaceDefinition =
 261                 ResponseParser.convertInterfaceDefinitionResponseToJavaObject(interfaceDefinitionStr);
 262     }
 263
 264 }