gerrit.onap Code Review - sdc.git/blob

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