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