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